From b788755dc0bdc1231be46218d52a09a032e22e72 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Fri, 17 Apr 2026 15:31:09 -0400 Subject: [PATCH 01/13] add re2js to codebase. change logic.ts to call it. fix some tests with broken imports. --- package.json | 2 +- packages/cel/package-lock.json | 270 ++ packages/cel/package.json | 10 +- packages/cel/src/checker.test.ts | 2 +- packages/cel/src/re2/CharClass.ts | 306 ++ packages/cel/src/re2/CharGroup.ts | 85 + packages/cel/src/re2/Codepoint.ts | 58 + packages/cel/src/re2/Compiler.ts | 306 ++ packages/cel/src/re2/DFA.ts | 452 ++ packages/cel/src/re2/Inst.ts | 90 + packages/cel/src/re2/MachineInput.ts | 100 + packages/cel/src/re2/Parser.ts | 1587 +++++++ packages/cel/src/re2/Prefilter.ts | 173 + packages/cel/src/re2/Prog.ts | 168 + packages/cel/src/re2/RE2.ts | 260 ++ packages/cel/src/re2/RE2Flags.ts | 45 + packages/cel/src/re2/Regexp.ts | 108 + packages/cel/src/re2/Simplify.ts | 260 ++ packages/cel/src/re2/Unicode.ts | 163 + packages/cel/src/re2/UnicodeRangeTable.ts | 33 + packages/cel/src/re2/UnicodeTables.ts | 566 +++ packages/cel/src/re2/Utils.ts | 112 + packages/cel/src/re2/__fixtures__/basic.dat | 217 + packages/cel/src/re2/__fixtures__/find.ts | 211 + .../cel/src/re2/__fixtures__/nullsubexpr.dat | 73 + .../re2/__fixtures__/re2-exhaustive.txt.gz | Bin 0 -> 1195382 bytes .../cel/src/re2/__fixtures__/re2-search.txt | 3779 +++++++++++++++++ .../cel/src/re2/__fixtures__/repetition.dat | 163 + .../cel/src/re2/__tests__/BugHunt.test.ts | 96 + .../cel/src/re2/__tests__/CharClass.test.ts | 250 ++ .../cel/src/re2/__tests__/Codepoint.test.ts | 32 + packages/cel/src/re2/__tests__/DFA.test.ts | 117 + packages/cel/src/re2/__tests__/Exec.test.ts | 407 ++ packages/cel/src/re2/__tests__/Inst.test.ts | 49 + packages/cel/src/re2/__tests__/Parser.test.ts | 383 ++ .../cel/src/re2/__tests__/Prefilter.test.ts | 139 + .../cel/src/re2/__tests__/RE2Compile.test.ts | 55 + .../re2/__tests__/RE2ExecuteEngine.test.ts | 53 + .../cel/src/re2/__tests__/RE2Match.test.ts | 13 + .../src/re2/__tests__/RE2QuoteMeta.test.ts | 40 + .../src/re2/__tests__/StressBoundary.test.ts | 97 + .../re2/__tests__/StressErrorRecovery.test.ts | 65 + .../cel/src/re2/__tests__/StressFlags.test.ts | 80 + .../src/re2/__tests__/StressUnicode.test.ts | 89 + .../cel/src/re2/__tests__/Unicode.test.ts | 129 + .../re2/__tests__/UnicodeConformance.test.ts | 116 + .../cel/src/re2/__tests__/edge-cases.test.ts | 470 ++ packages/cel/src/re2/__tests__/index.test.ts | 217 + .../cel/src/re2/__tests__/stability.test.ts | 273 ++ packages/cel/src/re2/__utils__/chars.ts | 1 + packages/cel/src/re2/__utils__/parser.ts | 140 + packages/cel/src/re2/__utils__/unicode.ts | 14 + packages/cel/src/re2/exceptions.ts | 103 + packages/cel/src/re2/index.ts | 223 + packages/cel/src/std/logic.ts | 353 +- packages/cel/src/testing.ts | 2 +- scripts/codepointRange.js | 42 + scripts/genUnicodeTable.js | 493 +++ scripts/make_perl_groups.pl | 126 + 59 files changed, 14092 insertions(+), 174 deletions(-) create mode 100644 packages/cel/package-lock.json create mode 100644 packages/cel/src/re2/CharClass.ts create mode 100644 packages/cel/src/re2/CharGroup.ts create mode 100644 packages/cel/src/re2/Codepoint.ts create mode 100644 packages/cel/src/re2/Compiler.ts create mode 100644 packages/cel/src/re2/DFA.ts create mode 100644 packages/cel/src/re2/Inst.ts create mode 100644 packages/cel/src/re2/MachineInput.ts create mode 100644 packages/cel/src/re2/Parser.ts create mode 100644 packages/cel/src/re2/Prefilter.ts create mode 100644 packages/cel/src/re2/Prog.ts create mode 100644 packages/cel/src/re2/RE2.ts create mode 100644 packages/cel/src/re2/RE2Flags.ts create mode 100644 packages/cel/src/re2/Regexp.ts create mode 100644 packages/cel/src/re2/Simplify.ts create mode 100644 packages/cel/src/re2/Unicode.ts create mode 100644 packages/cel/src/re2/UnicodeRangeTable.ts create mode 100644 packages/cel/src/re2/UnicodeTables.ts create mode 100644 packages/cel/src/re2/Utils.ts create mode 100644 packages/cel/src/re2/__fixtures__/basic.dat create mode 100644 packages/cel/src/re2/__fixtures__/find.ts create mode 100644 packages/cel/src/re2/__fixtures__/nullsubexpr.dat create mode 100644 packages/cel/src/re2/__fixtures__/re2-exhaustive.txt.gz create mode 100644 packages/cel/src/re2/__fixtures__/re2-search.txt create mode 100644 packages/cel/src/re2/__fixtures__/repetition.dat create mode 100644 packages/cel/src/re2/__tests__/BugHunt.test.ts create mode 100644 packages/cel/src/re2/__tests__/CharClass.test.ts create mode 100644 packages/cel/src/re2/__tests__/Codepoint.test.ts create mode 100644 packages/cel/src/re2/__tests__/DFA.test.ts create mode 100644 packages/cel/src/re2/__tests__/Exec.test.ts create mode 100644 packages/cel/src/re2/__tests__/Inst.test.ts create mode 100644 packages/cel/src/re2/__tests__/Parser.test.ts create mode 100644 packages/cel/src/re2/__tests__/Prefilter.test.ts create mode 100644 packages/cel/src/re2/__tests__/RE2Compile.test.ts create mode 100644 packages/cel/src/re2/__tests__/RE2ExecuteEngine.test.ts create mode 100644 packages/cel/src/re2/__tests__/RE2Match.test.ts create mode 100644 packages/cel/src/re2/__tests__/RE2QuoteMeta.test.ts create mode 100644 packages/cel/src/re2/__tests__/StressBoundary.test.ts create mode 100644 packages/cel/src/re2/__tests__/StressErrorRecovery.test.ts create mode 100644 packages/cel/src/re2/__tests__/StressFlags.test.ts create mode 100644 packages/cel/src/re2/__tests__/StressUnicode.test.ts create mode 100644 packages/cel/src/re2/__tests__/Unicode.test.ts create mode 100644 packages/cel/src/re2/__tests__/UnicodeConformance.test.ts create mode 100644 packages/cel/src/re2/__tests__/edge-cases.test.ts create mode 100644 packages/cel/src/re2/__tests__/index.test.ts create mode 100644 packages/cel/src/re2/__tests__/stability.test.ts create mode 100644 packages/cel/src/re2/__utils__/chars.ts create mode 100644 packages/cel/src/re2/__utils__/parser.ts create mode 100644 packages/cel/src/re2/__utils__/unicode.ts create mode 100644 packages/cel/src/re2/exceptions.ts create mode 100644 packages/cel/src/re2/index.ts create mode 100644 scripts/codepointRange.js create mode 100644 scripts/genUnicodeTable.js create mode 100755 scripts/make_perl_groups.pl diff --git a/package.json b/package.json index 1ee9136..1eee930 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "private": true, - "scripts": { + "scripts": {I am "clean": "git clean -Xdf", "all": "turbo run --ui tui build format lint test attw license-header update-readme", "setversion": "node scripts/set-workspace-version.js", diff --git a/packages/cel/package-lock.json b/packages/cel/package-lock.json new file mode 100644 index 0000000..1ef2333 --- /dev/null +++ b/packages/cel/package-lock.json @@ -0,0 +1,270 @@ +{ + "name": "@bufbuild/cel", + "version": "0.4.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@bufbuild/cel", + "version": "0.4.0", + "license": "Apache-2.0", + "dependencies": { + "@bufbuild/cel-spec": "0.4.0" + }, + "devDependencies": { + "@unicode/unicode-16.0.0": "^1.6.16", + "expect-type": "^1.3.0", + "peggy": "^5.0.6", + "peggy-ts": "github:hudlow/peggy-ts#v0.0.9", + "unicode-property-value-aliases": "^3.9.0" + }, + "peerDependencies": { + "@bufbuild/protobuf": "^2.6.2" + } + }, + "node_modules/@bufbuild/cel-spec": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/@bufbuild/cel-spec/-/cel-spec-0.4.0.tgz", + "integrity": "sha512-dUS6f2fNt6KEumsYGE7YFxERZE5ZuyME1hQmGjtO8tkZhR6ow6/ne3v4Gik9cfdb9lSLK3AJ+vDxCdGWmDbWvA==", + "license": "Apache-2.0", + "peerDependencies": { + "@bufbuild/protobuf": "^2.6.2" + } + }, + "node_modules/@bufbuild/protobuf": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/@bufbuild/protobuf/-/protobuf-2.11.0.tgz", + "integrity": "sha512-sBXGT13cpmPR5BMgHE6UEEfEaShh5Ror6rfN3yEK5si7QVrtZg8LEPQb0VVhiLRUslD2yLnXtnRzG035J/mZXQ==", + "license": "(Apache-2.0 AND BSD-3-Clause)", + "peer": true + }, + "node_modules/@peggyjs/from-mem": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@peggyjs/from-mem/-/from-mem-3.1.3.tgz", + "integrity": "sha512-LLlgtfXIaeYXoOYovOI0spLM8ZXaqkAlmcRRrLzHJzLMqkU6Sw0R4KMoCoHx1PjaP815pSCBlS+BN6aD8t1Jgg==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "7.7.4" + }, + "engines": { + "node": ">=20.8" + } + }, + "node_modules/@ts-morph/common": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.28.1.tgz", + "integrity": "sha512-W74iWf7ILp1ZKNYXY5qbddNaml7e9Sedv5lvU1V8lftlitkc9Pq1A+jlH23ltDgWYeZFFEqGCD1Ies9hqu3O+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "minimatch": "^10.0.1", + "path-browserify": "^1.0.1", + "tinyglobby": "^0.2.14" + } + }, + "node_modules/@unicode/unicode-16.0.0": { + "version": "1.6.16", + "resolved": "https://registry.npmjs.org/@unicode/unicode-16.0.0/-/unicode-16.0.0-1.6.16.tgz", + "integrity": "sha512-R2Vxi0XEsCMD9WOQT85O2npa7g+i4RsJ8Xtn+/KODLqa5wH5zCTn5an6JILJhMSfFGD3t3amES2XnvUHnKjMZQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/brace-expansion": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz", + "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/code-block-writer": { + "version": "13.0.3", + "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-13.0.3.tgz", + "integrity": "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==", + "dev": true, + "license": "MIT" + }, + "node_modules/commander": { + "version": "14.0.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz", + "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + } + }, + "node_modules/expect-type": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/minimatch": { + "version": "10.2.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", + "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.5" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-browserify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", + "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==", + "dev": true, + "license": "MIT" + }, + "node_modules/peggy": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/peggy/-/peggy-5.1.0.tgz", + "integrity": "sha512-IEo5aYRZ2kXH4Qby06cjtL114PZnwLoTiA41vUmg2vPZgANn+c87m5BUurhuDr5/cu758ZlpgsAfBVx+hhO5+w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@peggyjs/from-mem": "3.1.3", + "commander": "^14.0.3", + "source-map-generator": "2.0.6" + }, + "bin": { + "peggy": "bin/peggy.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/peggy-ts": { + "version": "0.0.9", + "resolved": "git+ssh://git@github.com/hudlow/peggy-ts.git#9adcea0eadb89bea93cc6bece8a429e00df044e8", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "source-map-generator": "^2.0.2", + "ts-morph": "^27.0.2" + }, + "peerDependencies": { + "peggy": "^5.0.6" + } + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/source-map-generator": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/source-map-generator/-/source-map-generator-2.0.6.tgz", + "integrity": "sha512-IlassDs1Ve8nV6uyQZXF9kdkJpVKnMte2JZQXu13M0A5zwc+vu6+LNHfmxsHBMDtoZE21RHiKI0/xvpecZRCNg==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=20" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.16", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz", + "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/ts-morph": { + "version": "27.0.2", + "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-27.0.2.tgz", + "integrity": "sha512-fhUhgeljcrdZ+9DZND1De1029PrE+cMkIP7ooqkLRTrRLTqcki2AstsyJm0vRNbTbVCNJ0idGlbBrfqc7/nA8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@ts-morph/common": "~0.28.1", + "code-block-writer": "^13.0.3" + } + }, + "node_modules/unicode-property-value-aliases": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/unicode-property-value-aliases/-/unicode-property-value-aliases-3.9.0.tgz", + "integrity": "sha512-UFsQgFziRAXuFS9hN48PnwujNFwsuRWHj+bd840X7aYC1xa0MHlKsaxzapp5lM4C4HuAPko5cFiTUydeQ428Bg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + } + } +} diff --git a/packages/cel/package.json b/packages/cel/package.json index d931a0c..1362871 100644 --- a/packages/cel/package.json +++ b/packages/cel/package.json @@ -18,7 +18,7 @@ "scripts": { "generate": "cd ./src && peggy cel.peggy --format bare --extra-options '{\"typescript\":true}' --plugin peggy-ts -o parser.ts", "postgenerate": "biome format src/parser.ts --write", - "test": "npx tsx --test ./src/*.test.ts ./src/*/*.test.ts", + "test": "npx tsx --test ./src/*.test.ts ./src/*/*.test.ts ./src/re2/__tests__/*.test.ts", "prebuild": "rm -rf ./dist/*", "build": "npm run build:cjs && npm run build:esm", "build:cjs": "tsc --project tsconfig.json --module commonjs --verbatimModuleSyntax false --moduleResolution node10 --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'", @@ -44,7 +44,9 @@ }, "typesVersions": { "*": { - "ext": ["./dist/cjs/ext/index.d.ts"] + "ext": [ + "./dist/cjs/ext/index.d.ts" + ] } }, "peerDependencies": { @@ -54,8 +56,10 @@ "@bufbuild/cel-spec": "0.4.0" }, "devDependencies": { + "@unicode/unicode-16.0.0": "^1.6.16", + "expect-type": "^1.3.0", "peggy": "^5.0.6", "peggy-ts": "github:hudlow/peggy-ts#v0.0.9", - "expect-type": "^1.3.0" + "unicode-property-value-aliases": "^3.9.0" } } diff --git a/packages/cel/src/checker.test.ts b/packages/cel/src/checker.test.ts index 6fb6ad3..2005ca4 100644 --- a/packages/cel/src/checker.test.ts +++ b/packages/cel/src/checker.test.ts @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -import { getCheckingSuite } from "@bufbuild/cel-spec/testdata/tests.js"; +import { getCheckingSuite } from "../../cel-spec/dist/cjs/testdata/tests.js"; import { createExpressionFilter, runCheckingTest, diff --git a/packages/cel/src/re2/CharClass.ts b/packages/cel/src/re2/CharClass.ts new file mode 100644 index 0000000..4c16f8d --- /dev/null +++ b/packages/cel/src/re2/CharClass.ts @@ -0,0 +1,306 @@ +import { RE2Flags } from './RE2Flags' +import { Unicode } from './Unicode' +import { Utils } from './Utils' +/** + * A "builder"-style helper class for manipulating character classes represented as an array of + * pairs of runes [lo, hi], each denoting an inclusive interval. + * + * All methods mutate the internal state and return {@code this}, allowing operations to be chained. + */ +class CharClass { + // cmp() returns the ordering of the pair (a[i], a[i+1]) relative to + // (pivotFrom, pivotTo), where the first component of the pair (lo) is + // ordered naturally and the second component (hi) is in reverse order. + static cmp(array: number[], i: number, pivotFrom: number, pivotTo: number): number { + const cmp = array[i] - pivotFrom + return cmp !== 0 ? cmp : pivotTo - array[i + 1] + } + + // qsortIntPair() quicksorts pairs of ints in |array| according to lt(). + // Precondition: |left|, |right|, |this.len| must all be even; |this.len > 1|. + static qsortIntPair(array: number[], left: number, right: number): void { + const pivotIndex = (((left + right) / 2) | 0) & ~1 + const pivotFrom = array[pivotIndex] + const pivotTo = array[pivotIndex + 1] + let i = left + let j = right + while (i <= j) { + while (i < right && CharClass.cmp(array, i, pivotFrom, pivotTo) < 0) { + i += 2 + } + + while (j > left && CharClass.cmp(array, j, pivotFrom, pivotTo) > 0) { + j -= 2 + } + + if (i <= j) { + if (i !== j) { + let temp = array[i] + array[i] = array[j] + array[j] = temp + temp = array[i + 1] + array[i + 1] = array[j + 1] + array[j + 1] = temp + } + i += 2 + j -= 2 + } + } + + if (left < j) { + CharClass.qsortIntPair(array, left, j) + } + if (i < right) { + CharClass.qsortIntPair(array, i, right) + } + } + + r: any + len: number + + constructor(r = Utils.emptyInts()) { + this.r = r // inclusive ranges, pairs of [lo,hi]. r.length is even. + this.len = r.length // prefix of |r| that is defined. Even. + } + + // Returns the character class as an int array. Subsequent CharClass + // operations may mutate this array, so typically this is the last operation + // performed on a given CharClass instance. + toArray(): number[] { + if (this.len === this.r.length) { + return this.r + } else { + return this.r.slice(0, this.len) + } + } + + // cleanClass() sorts the ranges (pairs of elements) of this CharClass, + // merges them, and eliminates duplicates. + cleanClass(): this { + if (this.len < 4) { + return this + } + // Sort by lo increasing, hi decreasing to break ties. + CharClass.qsortIntPair(this.r, 0, this.len - 2) + // Merge abutting, overlapping. + let w = 2 // write index + for (let i = 2; i < this.len; i += 2) { + { + const lo = this.r[i] + const hi = this.r[i + 1] + if (lo <= this.r[w - 1] + 1) { + // merge with previous range + if (hi > this.r[w - 1]) { + this.r[w - 1] = hi + } + continue + } + // new disjoint range + this.r[w] = lo + this.r[w + 1] = hi + w += 2 + } + } + this.len = w + return this + } + + // appendLiteral() appends the literal |x| to this CharClass. + appendLiteral(x: number, flags: number): this { + return (flags & RE2Flags.FOLD_CASE) !== 0 + ? this.appendFoldedRange(x, x) + : this.appendRange(x, x) + } + + // appendRange() appends the range [lo-hi] (inclusive) to this CharClass. + appendRange(lo: number, hi: number): this { + // Expand last range or next to last range if it overlaps or abuts. + // Checking two ranges helps when appending case-folded + // alphabets, so that one range can be expanding A-Z and the + // other expanding a-z. + if (this.len > 0) { + for (let i = 2; i <= 4; i += 2) { + // twice, using i=2, i=4 + if (this.len >= i) { + const rlo = this.r[this.len - i] + const rhi = this.r[this.len - i + 1] + if (lo <= rhi + 1 && rlo <= hi + 1) { + if (lo < rlo) { + this.r[this.len - i] = lo + } + if (hi > rhi) { + this.r[this.len - i + 1] = hi + } + return this + } + } + } + } + + this.r[this.len++] = lo + this.r[this.len++] = hi + return this + } + + // appendFoldedRange() appends the range [lo-hi] and its case + // folding-equivalent runes to this CharClass. + appendFoldedRange(lo: number, hi: number): this { + // Optimizations. + if (lo <= Unicode.MIN_FOLD && hi >= Unicode.MAX_FOLD) { + // Range is full: folding can't add more. + return this.appendRange(lo, hi) + } + if (hi < Unicode.MIN_FOLD || lo > Unicode.MAX_FOLD) { + // Range is outside folding possibilities. + return this.appendRange(lo, hi) + } + if (lo < Unicode.MIN_FOLD) { + // [lo, minFold-1] needs no folding. + this.appendRange(lo, Unicode.MIN_FOLD - 1) + lo = Unicode.MIN_FOLD + } + if (hi > Unicode.MAX_FOLD) { + // [maxFold+1, hi] needs no folding. + this.appendRange(Unicode.MAX_FOLD + 1, hi) + hi = Unicode.MAX_FOLD + } + + // Brute force. Depend on appendRange to coalesce ranges on the fly. + for (let c = lo; c <= hi; c++) { + this.appendRange(c, c) + + for (let f = Unicode.simpleFold(c); f !== c; f = Unicode.simpleFold(f)) { + this.appendRange(f, f) + } + } + return this + } + + // appendClass() appends the class |x| to this CharClass. + // It assumes |x| is clean. Does not mutate |x|. + appendClass(x: number[]): this { + for (let i = 0; i < x.length; i += 2) { + this.appendRange(x[i], x[i + 1]) + } + return this + } + + // appendFoldedClass() appends the case folding of the class |x| to this + // CharClass. Does not mutate |x|. + appendFoldedClass(x: number[]): this { + for (let i = 0; i < x.length; i += 2) { + this.appendFoldedRange(x[i], x[i + 1]) + } + return this + } + + // appendNegatedClass() append the negation of the class |x| to this + // CharClass. It assumes |x| is clean. Does not mutate |x|. + appendNegatedClass(x: number[]): this { + let nextLo = 0 + for (let i = 0; i < x.length; i += 2) { + const lo = x[i] + const hi = x[i + 1] + if (nextLo <= lo - 1) { + this.appendRange(nextLo, lo - 1) + } + nextLo = hi + 1 + } + if (nextLo <= Unicode.MAX_RUNE) { + this.appendRange(nextLo, Unicode.MAX_RUNE) + } + return this + } + + // appendTable() appends the Unicode range table |table| to this CharClass. + // Does not mutate |table|. + appendTable(table: any): this { + for (let i = 0; i < table.length; ++i) { + const lo = table.getLo(i) + const hi = table.getHi(i) + const stride = table.getStride(i) + if (stride === 1) { + this.appendRange(lo, hi) + continue + } + for (let c = lo; c <= hi; c += stride) { + this.appendRange(c, c) + } + } + return this + } + + // appendNegatedTable() returns the result of appending the negation of range + // table |table| to this CharClass. Does not mutate |table|. + appendNegatedTable(table: any): this { + let nextLo = 0 + for (let i = 0; i < table.length; ++i) { + const lo = table.getLo(i) + const hi = table.getHi(i) + const stride = table.getStride(i) + if (stride === 1) { + if (nextLo <= lo - 1) { + this.appendRange(nextLo, lo - 1) + } + nextLo = hi + 1 + continue + } + for (let c = lo; c <= hi; c += stride) { + if (nextLo <= c - 1) { + this.appendRange(nextLo, c - 1) + } + nextLo = c + 1 + } + } + if (nextLo <= Unicode.MAX_RUNE) { + this.appendRange(nextLo, Unicode.MAX_RUNE) + } + return this + } + + // appendTableWithSign() calls append{,Negated}Table depending on sign. + // Does not mutate |table|. + appendTableWithSign(table: any, sign: number): this { + return sign < 0 ? this.appendNegatedTable(table) : this.appendTable(table) + } + + // negateClass() negates this CharClass, which must already be clean. + negateClass(): this { + let nextLo = 0 // lo end of next class to add + let w = 0 // write index + for (let i = 0; i < this.len; i += 2) { + const lo = this.r[i] + const hi = this.r[i + 1] + if (nextLo <= lo - 1) { + this.r[w] = nextLo + this.r[w + 1] = lo - 1 + w += 2 + } + nextLo = hi + 1 + } + this.len = w + if (nextLo <= Unicode.MAX_RUNE) { + this.r[this.len++] = nextLo + this.r[this.len++] = Unicode.MAX_RUNE + } + return this + } + + // appendClassWithSign() calls appendClass() if sign is +1 or + // appendNegatedClass if sign is -1. Does not mutate |x|. + appendClassWithSign(x: number[], sign: number): this { + return sign < 0 ? this.appendNegatedClass(x) : this.appendClass(x) + } + + // appendGroup() appends CharGroup |g| to this CharClass, folding iff + // |foldCase|. Does not mutate |g|. + appendGroup(g: any, foldCase: boolean): this { + let cls = g.cls + if (foldCase) { + cls = new CharClass().appendFoldedClass(cls).cleanClass().toArray() + } + return this.appendClassWithSign(cls, g.sign) + } +} + +export { CharClass } diff --git a/packages/cel/src/re2/CharGroup.ts b/packages/cel/src/re2/CharGroup.ts new file mode 100644 index 0000000..ef2215b --- /dev/null +++ b/packages/cel/src/re2/CharGroup.ts @@ -0,0 +1,85 @@ +// GENERATED BY tools/scripts/make_perl_groups.pl; DO NOT EDIT. +// ./tools/scripts/make_perl_groups.pl > src/CharGroup.js + +class CharGroup { + sign: number + cls: number[] + + constructor(sign: number, cls: number[]) { + this.sign = sign + this.cls = cls + } +} + +const code1 = [0x30, 0x39] +const code2 = [0x9, 0xa, 0xc, 0xd, 0x20, 0x20] +const code3 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a] + +let _PERL_GROUPS: Map | null = null +const getPerlGroups = (): Map => { + if (!_PERL_GROUPS) { + _PERL_GROUPS = new Map([ + ['\\d', new CharGroup(+1, code1)], + ['\\D', new CharGroup(-1, code1)], + ['\\s', new CharGroup(+1, code2)], + ['\\S', new CharGroup(-1, code2)], + ['\\w', new CharGroup(+1, code3)], + ['\\W', new CharGroup(-1, code3)] + ]) + } + return _PERL_GROUPS +} + +const code4 = [0x30, 0x39, 0x41, 0x5a, 0x61, 0x7a] +const code5 = [0x41, 0x5a, 0x61, 0x7a] +const code6 = [0x0, 0x7f] +const code7 = [0x9, 0x9, 0x20, 0x20] +const code8 = [0x0, 0x1f, 0x7f, 0x7f] +const code9 = [0x30, 0x39] +const code10 = [0x21, 0x7e] +const code11 = [0x61, 0x7a] +const code12 = [0x20, 0x7e] +const code13 = [0x21, 0x2f, 0x3a, 0x40, 0x5b, 0x60, 0x7b, 0x7e] +const code14 = [0x9, 0xd, 0x20, 0x20] +const code15 = [0x41, 0x5a] +const code16 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a] +const code17 = [0x30, 0x39, 0x41, 0x46, 0x61, 0x66] + +let _POSIX_GROUPS: Map | null = null +const getPosixGroups = (): Map => { + if (!_POSIX_GROUPS) { + _POSIX_GROUPS = new Map([ + ['[:alnum:]', new CharGroup(+1, code4)], + ['[:^alnum:]', new CharGroup(-1, code4)], + ['[:alpha:]', new CharGroup(+1, code5)], + ['[:^alpha:]', new CharGroup(-1, code5)], + ['[:ascii:]', new CharGroup(+1, code6)], + ['[:^ascii:]', new CharGroup(-1, code6)], + ['[:blank:]', new CharGroup(+1, code7)], + ['[:^blank:]', new CharGroup(-1, code7)], + ['[:cntrl:]', new CharGroup(+1, code8)], + ['[:^cntrl:]', new CharGroup(-1, code8)], + ['[:digit:]', new CharGroup(+1, code9)], + ['[:^digit:]', new CharGroup(-1, code9)], + ['[:graph:]', new CharGroup(+1, code10)], + ['[:^graph:]', new CharGroup(-1, code10)], + ['[:lower:]', new CharGroup(+1, code11)], + ['[:^lower:]', new CharGroup(-1, code11)], + ['[:print:]', new CharGroup(+1, code12)], + ['[:^print:]', new CharGroup(-1, code12)], + ['[:punct:]', new CharGroup(+1, code13)], + ['[:^punct:]', new CharGroup(-1, code13)], + ['[:space:]', new CharGroup(+1, code14)], + ['[:^space:]', new CharGroup(-1, code14)], + ['[:upper:]', new CharGroup(+1, code15)], + ['[:^upper:]', new CharGroup(-1, code15)], + ['[:word:]', new CharGroup(+1, code16)], + ['[:^word:]', new CharGroup(-1, code16)], + ['[:xdigit:]', new CharGroup(+1, code17)], + ['[:^xdigit:]', new CharGroup(-1, code17)] + ]) + } + return _POSIX_GROUPS +} + +export { CharGroup, getPerlGroups, getPosixGroups } diff --git a/packages/cel/src/re2/Codepoint.ts b/packages/cel/src/re2/Codepoint.ts new file mode 100644 index 0000000..ad31b66 --- /dev/null +++ b/packages/cel/src/re2/Codepoint.ts @@ -0,0 +1,58 @@ +/** + * Various constants and helper for unicode codepoints. + */ +const ASCII_SIZE = 128 +let _ASCII_TO_UPPER: Int32Array | null = null +let _ASCII_TO_LOWER: Int32Array | null = null + +const getAsciiToUpper = (): Int32Array => { + if (!_ASCII_TO_UPPER) { + _ASCII_TO_UPPER = new Int32Array(ASCII_SIZE) + for (let i = 0; i < ASCII_SIZE; i++) { + _ASCII_TO_UPPER[i] = i >= 97 && i <= 122 ? i - 32 : i + } + } + return _ASCII_TO_UPPER +} + +const getAsciiToLower = (): Int32Array => { + if (!_ASCII_TO_LOWER) { + _ASCII_TO_LOWER = new Int32Array(ASCII_SIZE) + for (let i = 0; i < ASCII_SIZE; i++) { + _ASCII_TO_LOWER[i] = i >= 65 && i <= 90 ? i + 32 : i + } + } + return _ASCII_TO_LOWER +} + +class Codepoint { + static toUpperCase(codepoint: number): number { + if (codepoint < ASCII_SIZE) return getAsciiToUpper()[codepoint] + + const s = String.fromCodePoint(codepoint).toUpperCase() + if (s.length > 1) { + return codepoint + } + const sOrigin = String.fromCodePoint(s.codePointAt(0)!).toLowerCase() + if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) { + return codepoint + } + return s.codePointAt(0)! + } + + static toLowerCase(codepoint: number): number { + if (codepoint < ASCII_SIZE) return getAsciiToLower()[codepoint] + + const s = String.fromCodePoint(codepoint).toLowerCase() + if (s.length > 1) { + return codepoint + } + const sOrigin = String.fromCodePoint(s.codePointAt(0)!).toUpperCase() + if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) { + return codepoint + } + return s.codePointAt(0)! + } +} + +export { Codepoint } diff --git a/packages/cel/src/re2/Compiler.ts b/packages/cel/src/re2/Compiler.ts new file mode 100644 index 0000000..13110b9 --- /dev/null +++ b/packages/cel/src/re2/Compiler.ts @@ -0,0 +1,306 @@ +import { RE2Flags } from './RE2Flags' +import { Unicode } from './Unicode' +import { Utils } from './Utils' +import { Regexp } from './Regexp' +import { Inst } from './Inst' +import { Prog, PatchList } from './Prog' +import { RE2JSCompileException } from './exceptions' + +/** + * A fragment of a compiled regular expression program. + * + * @see http://swtch.com/~rsc/regexp/regexp1.html + * @class + */ +class Frag { + i: number + out: any + nullable: boolean + + constructor(i = 0, out: PatchList | number = new PatchList(), nullable = false) { + this.i = i // an instruction address (pc). + this.out = out // a patch list; see explanation in Prog.js + this.nullable = nullable // whether the fragment can match the empty string + } +} +/** + * Compiler from {@code Regexp} (RE2 abstract syntax) to {@code RE2} (compiled regular expression). + * + * The only entry point is {@link #compileRegexp}. + */ +class Compiler { + prog: any + + static ANY_RUNE_NOT_NL(): number[] { + return [0, 0x0a - 1, 0x0a + 1, Unicode.MAX_RUNE] + } + + static ANY_RUNE(): number[] { + return [0, Unicode.MAX_RUNE] + } + + static compileRegexp(re: Regexp): Prog { + const c = new Compiler() + const f = c.compile(re) + c.prog.patch(f.out, c.newInst(Inst.MATCH).i) + c.prog.start = f.i + return c.prog + } + + static compileSet(regexps: Regexp[]): Prog { + const c = new Compiler() + + if (regexps.length === 0) { + c.prog.start = c.newInst(Inst.FAIL).i + return c.prog + } + + let starts = [] + for (let i = 0; i < regexps.length; i++) { + const f = c.compile(regexps[i]) + const m = c.newInst(Inst.MATCH) + c.prog.getInst(m.i).arg = i // Store the regex index + c.prog.patch(f.out, m.i) + starts.push(f.i) + } + + // Link starts together via ALT + let start = starts[0] + for (let i = 1; i < starts.length; i++) { + const f = c.newInst(Inst.ALT) + const inst = c.prog.getInst(f.i) + inst.out = start + inst.arg = starts[i] + start = f.i + } + c.prog.start = start + return c.prog + } + + constructor() { + this.prog = new Prog() + this.newInst(Inst.FAIL) + } + + newInst(op: number): Frag { + this.prog.addInst(op) + return new Frag(this.prog.numInst() - 1, 0, true) + } + + // Returns a no-op fragment. Sometimes unavoidable. + nop(): Frag { + const f = this.newInst(Inst.NOP) + f.out = new PatchList(f.i << 1, f.i << 1) + return f + } + + fail(): Frag { + return new Frag() + } + + // Given fragment a, returns (a) capturing as \n. + // Given a fragment a, returns a fragment with capturing parens around a. + cap(arg: number): Frag { + const f = this.newInst(Inst.CAPTURE) + f.out = new PatchList(f.i << 1, f.i << 1) + this.prog.getInst(f.i).arg = arg + if (this.prog.numCap < arg + 1) { + this.prog.numCap = arg + 1 + } + return f + } + + // Given fragments a and b, returns ab; a|b + cat(f1: Frag, f2: Frag): Frag { + // concat of failure is failure + if (f1.i === 0 || f2.i === 0) { + return this.fail() + } + // eslint-disable-next-line no-warning-comments + // TODO(rsc): elide nop + this.prog.patch(f1.out, f2.i) + return new Frag(f1.i, f2.out, f1.nullable && f2.nullable) + } + + // Given fragments for a and b, returns fragment for a|b. + alt(f1: Frag, f2: Frag): Frag { + // alt of failure is other + if (f1.i === 0) { + return f2 + } + if (f2.i === 0) { + return f1 + } + const f = this.newInst(Inst.ALT) + const i = this.prog.getInst(f.i) + i.out = f1.i + i.arg = f2.i + f.out = this.prog.append(f1.out, f2.out) + f.nullable = f1.nullable || f2.nullable + return f + } + + // loop returns the fragment for the main loop of a plus or star. + // For plus, it can be used directly. with f1.i as the entry. + // For star, it can be used directly when f1 can't match an empty string. + // (When f1 can match an empty string, f1* must be implemented as (f1+)? + // to get the priority match order correct.) + loop(f1: Frag, nongreedy: boolean): Frag { + const f = this.newInst(Inst.ALT) + const i = this.prog.getInst(f.i) + if (nongreedy) { + i.arg = f1.i + f.out = new PatchList(f.i << 1, f.i << 1) + } else { + i.out = f1.i + f.out = new PatchList((f.i << 1) | 1, (f.i << 1) | 1) + } + this.prog.patch(f1.out, f.i) + return f + } + + // Given a fragment for a, returns a fragment for a? or a?? (if nongreedy) + quest(f1: Frag, nongreedy: boolean): Frag { + const f = this.newInst(Inst.ALT) + const i = this.prog.getInst(f.i) + if (nongreedy) { + i.arg = f1.i + f.out = new PatchList(f.i << 1, f.i << 1) + } else { + i.out = f1.i + f.out = new PatchList((f.i << 1) | 1, (f.i << 1) | 1) + } + f.out = this.prog.append(f.out, f1.out) + return f + } + + // Given a fragment a, returns a fragment for a* or a*? (if nongreedy) + star(f1: Frag, nongreedy: boolean): Frag { + if (f1.nullable) { + return this.quest(this.plus(f1, nongreedy), nongreedy) + } + return this.loop(f1, nongreedy) + } + + // Given a fragment for a, returns a fragment for a+ or a+? (if nongreedy) + plus(f1: Frag, nongreedy: boolean): Frag { + return new Frag(f1.i, this.loop(f1, nongreedy).out, f1.nullable) + } + + // op is a bitmask of EMPTY_* flags. + empty(op: number): Frag { + const f = this.newInst(Inst.EMPTY_WIDTH) + this.prog.getInst(f.i).arg = op + f.out = new PatchList(f.i << 1, f.i << 1) + return f + } + + // flags : parser flags + rune(runes: number[], flags: number): Frag { + const f = this.newInst(Inst.RUNE) + f.nullable = false + const i = this.prog.getInst(f.i) + i.runes = runes + flags &= RE2Flags.FOLD_CASE + if (runes.length !== 1 || Unicode.simpleFold(runes[0]) === runes[0]) { + flags &= ~RE2Flags.FOLD_CASE + } + i.arg = flags + f.out = new PatchList(f.i << 1, f.i << 1) + if ( + ((flags & RE2Flags.FOLD_CASE) === 0 && runes.length === 1) || + (runes.length === 2 && runes[0] === runes[1]) + ) { + i.op = Inst.RUNE1 + } else if (runes.length === 2 && runes[0] === 0 && runes[1] === Unicode.MAX_RUNE) { + i.op = Inst.RUNE_ANY + } else if ( + runes.length === 4 && + runes[0] === 0 && + runes[1] === 0x0a - 1 && + runes[2] === 0x0a + 1 && + runes[3] === Unicode.MAX_RUNE + ) { + i.op = Inst.RUNE_ANY_NOT_NL + } + return f + } + + compile(re: Regexp): Frag { + switch (re.op) { + case Regexp.Op.NO_MATCH: + return this.fail() + case Regexp.Op.EMPTY_MATCH: + return this.nop() + case Regexp.Op.LITERAL: + if (re.runes.length === 0) { + return this.nop() + } else { + let f: Frag | null = null + for (let r of re.runes) { + const f1 = this.rune([r], re.flags) + f = f === null ? f1 : this.cat(f, f1) + } + return f! + } + case Regexp.Op.CHAR_CLASS: + return this.rune(re.runes, re.flags) + case Regexp.Op.ANY_CHAR_NOT_NL: + return this.rune(Compiler.ANY_RUNE_NOT_NL(), 0) + case Regexp.Op.ANY_CHAR: + return this.rune(Compiler.ANY_RUNE(), 0) + case Regexp.Op.BEGIN_LINE: + return this.empty(Utils.EMPTY_BEGIN_LINE) + case Regexp.Op.END_LINE: + return this.empty(Utils.EMPTY_END_LINE) + case Regexp.Op.BEGIN_TEXT: + return this.empty(Utils.EMPTY_BEGIN_TEXT) + case Regexp.Op.END_TEXT: + return this.empty(Utils.EMPTY_END_TEXT) + case Regexp.Op.WORD_BOUNDARY: + return this.empty(Utils.EMPTY_WORD_BOUNDARY) + case Regexp.Op.NO_WORD_BOUNDARY: + return this.empty(Utils.EMPTY_NO_WORD_BOUNDARY) + case Regexp.Op.CAPTURE: { + const bra = this.cap(re.cap << 1) + const sub = this.compile(re.subs[0]) + const ket = this.cap((re.cap << 1) | 1) + return this.cat(this.cat(bra, sub), ket) + } + case Regexp.Op.STAR: + return this.star(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0) + case Regexp.Op.PLUS: + return this.plus(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0) + case Regexp.Op.QUEST: + return this.quest(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0) + case Regexp.Op.CONCAT: { + if (re.subs.length === 0) { + return this.nop() + } else { + let f: Frag | null = null + for (let sub of re.subs) { + const f1 = this.compile(sub) + f = f === null ? f1 : this.cat(f, f1) + } + return f! + } + } + case Regexp.Op.ALTERNATE: { + if (re.subs.length === 0) { + return this.nop() + } else { + let f: Frag | null = null + for (let sub of re.subs) { + const f1 = this.compile(sub) + f = f === null ? f1 : this.alt(f, f1) + } + return f! + } + } + default: + throw new RE2JSCompileException('regexp: unhandled case in compile') + } + } +} + +export { Compiler } diff --git a/packages/cel/src/re2/DFA.ts b/packages/cel/src/re2/DFA.ts new file mode 100644 index 0000000..86db58c --- /dev/null +++ b/packages/cel/src/re2/DFA.ts @@ -0,0 +1,452 @@ +import { Inst } from './Inst' +import { RE2Flags } from './RE2Flags' +import { Unicode } from './Unicode' +import { Utils } from './Utils' + +// FNV-1a 32-bit hash for an array of integers. +const hashPCs = (pcs: Int32Array): number => { + let h = -2128831035 + for (let i = 0; i < pcs.length; i++) { + h ^= pcs[i] + h = Math.imul(h, 16777619) + } + return h +} + +const arraysEqual = (a: Int32Array, b: Int32Array): boolean => { + if (a.length !== b.length) return false + for (let i = 0; i < a.length; i++) { + if (a[i] !== b[i]) return false + } + return true +} + +class DFAState { + nfaStates: any + isMatch: boolean + hasEmptyWidth: boolean + matchIDs: number[] + nextAscii: any[] + nextMap: Map + + constructor( + nfaStates: Int32Array, + isMatch: boolean, + hasEmptyWidth: boolean, + matchIDs: number[] = [] + ) { + this.nfaStates = nfaStates // Int32Array of Instruction PCs + this.isMatch = isMatch + this.hasEmptyWidth = hasEmptyWidth // true if any PC is an EMPTY_WIDTH instruction + this.matchIDs = matchIDs + this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null) + this.nextMap = new Map() + } +} + +class DFA { + prog: any + stateCache: Map + stateCount: number + startState: DFAState | null + stateLimit: number + cacheClears: number + failed: boolean + + static MAX_CACHE_CLEARS = 5 + + constructor(prog: any) { + this.prog = prog + this.stateCache = new Map() + this.stateCount = 0 + this.startState = null + this.stateLimit = 10000 + this.cacheClears = 0 + this.failed = false + } + + // Follows epsilon transitions to find all reachable states without consuming a char. + // Stops at EMPTY_WIDTH (includes the PC but does not follow through). + computeClosure(pcs: number[]): { + pcs: Int32Array + isMatch: boolean + hasEmptyWidth: boolean + matchIDs: number[] + } { + const closure = new Set() + const stack = [...pcs] + let isMatch = false + let hasEmptyWidth = false + const matchIDs: number[] = [] + + while (stack.length > 0) { + const pc = stack.pop() + if (closure.has(pc)) continue + closure.add(pc) + + const inst = this.prog.getInst(pc) + switch (inst.op) { + case Inst.MATCH: + isMatch = true + if (!matchIDs.includes(inst.arg)) matchIDs.push(inst.arg) + break + case Inst.ALT: + case Inst.ALT_MATCH: + stack.push(inst.out) + stack.push(inst.arg) + break + case Inst.NOP: + case Inst.CAPTURE: + stack.push(inst.out) + break + case Inst.EMPTY_WIDTH: + // Include in state but don't follow through — resolved at step time with context + hasEmptyWidth = true + break + } + } + + const sortedPCs = Int32Array.from(closure).sort() + matchIDs.sort((a, b) => a - b) + return { pcs: sortedPCs, isMatch, hasEmptyWidth, matchIDs } + } + + // Resolve EMPTY_WIDTH PCs using the given context. + // Returns { resolvedPCs: Set, isMatch: boolean } + resolveEmptyWidth( + nfaStates: Int32Array, + context: number + ): { resolvedPCs: Set; isMatch: boolean } { + const resolved = new Set() + const stack: number[] = [] + let isMatch = false + + // Start with all PCs in the state + for (let i = 0; i < nfaStates.length; i++) { + const pc = nfaStates[i] + const inst = this.prog.getInst(pc) + if (inst.op === Inst.EMPTY_WIDTH) { + // Check if context satisfies the empty-width condition + if ((inst.arg & ~context) === 0) { + stack.push(inst.out) + } + } else { + resolved.add(pc) + if (inst.op === Inst.MATCH) { + isMatch = true + } + } + } + + // Follow through from resolved EMPTY_WIDTH transitions + while (stack.length > 0) { + const pc = stack.pop()! + if (resolved.has(pc)) continue + resolved.add(pc) + + const inst = this.prog.getInst(pc) + switch (inst.op) { + case Inst.MATCH: + isMatch = true + break + case Inst.ALT: + case Inst.ALT_MATCH: + stack.push(inst.out) + stack.push(inst.arg) + break + case Inst.NOP: + case Inst.CAPTURE: + stack.push(inst.out) + break + case Inst.EMPTY_WIDTH: + if ((inst.arg & ~context) === 0) { + stack.push(inst.out) + } + break + } + } + + return { resolvedPCs: resolved, isMatch } + } + + getState(pcs: number[]): DFAState | null { + const closureResult = this.computeClosure(pcs) + + const sortedPCs = closureResult.pcs + const hash = hashPCs(sortedPCs) + + let bucket = this.stateCache.get(hash) + if (bucket) { + for (let i = 0; i < bucket.length; i++) { + const state = bucket[i] + if (arraysEqual(state.nfaStates, sortedPCs)) { + return state + } + } + } else { + bucket = [] + this.stateCache.set(hash, bucket) + } + + if (this.failed) return null + + if (this.stateCount >= this.stateLimit) { + this.stateCache.clear() + this.stateCount = 0 + this.startState = null + this.cacheClears++ + + if (this.cacheClears >= DFA.MAX_CACHE_CLEARS) { + this.failed = true + } + return null + } + + const state = new DFAState( + sortedPCs, + closureResult.isMatch, + closureResult.hasEmptyWidth, + closureResult.matchIDs + ) + bucket.push(state) + this.stateCount++ + return state + } + + // Compute the next DFA state given a current state, a character, and context. + // Context is needed only when the state has EMPTY_WIDTH PCs. + step(state: DFAState, charCode: number, anchor: number, context: number): DFAState | null { + // Cache lookup + let cacheKey + if (state.hasEmptyWidth) { + // Context-dependent: include context in key + cacheKey = charCode * 128 + (context & 0x3f) * 2 + (anchor === RE2Flags.UNANCHORED ? 0 : 1) + if (state.nextMap.has(cacheKey)) { + return state.nextMap.get(cacheKey) + } + } else { + // Context-independent: use original caching + if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) { + const next = state.nextAscii[charCode] + if (next !== null) { + return next + } + } else { + cacheKey = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1) + if (state.nextMap.has(cacheKey)) { + return state.nextMap.get(cacheKey) + } + } + } + + // Determine which PCs to check for RUNE matches + let activePCs + if (state.hasEmptyWidth) { + const { resolvedPCs } = this.resolveEmptyWidth(state.nfaStates, context) + activePCs = resolvedPCs + } else { + activePCs = state.nfaStates + } + + // Collect next PCs from RUNE matches + const nextPCs = [] + const iterPCs = activePCs instanceof Set ? activePCs : state.nfaStates + for (const pc of iterPCs) { + const inst = this.prog.getInst(pc) + if (Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) { + nextPCs.push(inst.out) + } + } + + if (anchor === RE2Flags.UNANCHORED) { + nextPCs.push(this.prog.start) + } + + const nextState = this.getState(nextPCs) + + // Cache the result + if (state.hasEmptyWidth) { + state.nextMap.set(cacheKey, nextState) + } else if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) { + state.nextAscii[charCode] = nextState + } else { + cacheKey = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1) + state.nextMap.set(cacheKey, nextState) + } + + return nextState + } + + // Check if a state matches after resolving EMPTY_WIDTH with end-of-input context + checkEndMatch(state: DFAState, prevRune: number): boolean { + if (state.isMatch) return true + if (!state.hasEmptyWidth) return false + + const endContext = Utils.emptyOpContext(prevRune, -1) + const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endContext) + return isMatch + } + + // The hot loop: Execute the Lazy DFA + match(input: any, pos: number, anchor: number): boolean | null { + if (!this.startState) { + this.startState = this.getState([this.prog.start]) + if (!this.startState) return null + } + + const endPos = input.endPos() + let currentState: DFAState | null = this.startState + // prevRune: the rune immediately before position `pos`. For pos=0 this is + // -1 (beginning-of-text sentinel). For pos>0 we query the input so that + // ^, \A, and \b anchors use the correct context when matching begins + // from a mid-text offset. + let prevRune = -1 + if (pos > 0) { + const r = input.step(pos - 1) >> 3 + if (r >= 0) prevRune = r + } + + // Check if start state matches directly (e.g., empty pattern) + if (currentState.isMatch) { + if (anchor === RE2Flags.ANCHOR_BOTH) { + if (pos === endPos) return true + } else { + return true + } + } + + let i = pos + + while (i < endPos) { + const r = input.step(i) + const rune = r >> 3 + const width = r & 7 + if (width === 0) break + + // Compute context at position i (between prevRune and rune) + const context = Utils.emptyOpContext(prevRune, rune) + + // Before consuming: check if EMPTY_WIDTH in current state resolves to MATCH + if (currentState.hasEmptyWidth) { + const { isMatch } = this.resolveEmptyWidth(currentState.nfaStates, context) + if (isMatch) { + if (anchor === RE2Flags.ANCHOR_BOTH) { + // Match at position i (before consuming rune) — only valid if i === endPos + // which can't happen in this loop, so skip + } else { + return true + } + } + } + + // Consume rune and transition to next state + if ( + !currentState.hasEmptyWidth && + anchor === RE2Flags.UNANCHORED && + rune <= Unicode.MAX_ASCII + ) { + currentState = + currentState.nextAscii[rune] || this.step(currentState, rune, anchor, context) + } else { + currentState = this.step(currentState, rune, anchor, context) + } + + if (currentState === null) return null + + // After consuming: check if new state is a match + if (currentState.isMatch) { + if (anchor === RE2Flags.ANCHOR_BOTH) { + if (i + width === endPos) return true + } else { + return true + } + } + + if (currentState.nfaStates.length === 0) { + if (anchor !== RE2Flags.UNANCHORED) return false + } + + prevRune = rune + i += width + } + + // After the loop: check EMPTY_WIDTH at end of text. + // For all anchor modes, a resolved MATCH here means the pattern succeeded: + // UNANCHORED/ANCHOR_START accept any match; ANCHOR_BOTH accepts it because + // we have consumed the entire input up to endPos. + if (currentState.hasEmptyWidth) { + const endContext = Utils.emptyOpContext(prevRune, -1) + const { isMatch } = this.resolveEmptyWidth(currentState.nfaStates, endContext) + if (isMatch) return true + } + + return false + } + + // Multi-Pattern Set matching (kept for compatibility) + matchSet(input: any, pos: number, anchor: number): number[] | null { + if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) { + return [] + } + + if (!this.startState) { + this.startState = this.getState([this.prog.start]) + if (!this.startState) return null + } + + let endPos = input.endPos() + let currentState: DFAState | null = this.startState + let prevRune = -1 + const matches = new Set() + + const checkMatch = (state: DFAState, currentPos: number, prevR: number): void => { + if (state.isMatch) { + if (anchor === RE2Flags.ANCHOR_BOTH) { + if (currentPos === endPos) { + state.matchIDs.forEach((id: number) => matches.add(id)) + } + } else { + state.matchIDs.forEach((id: number) => matches.add(id)) + } + } + // Also check EMPTY_WIDTH resolution at end + if (state.hasEmptyWidth && currentPos === endPos) { + const endCtx = Utils.emptyOpContext(prevR, -1) + const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endCtx) + if (isMatch) { + if (anchor === RE2Flags.ANCHOR_BOTH) { + state.matchIDs.forEach((id: number) => matches.add(id)) + } + } + } + } + + checkMatch(currentState, pos, prevRune) + + let i = pos + while (i < endPos) { + const r = input.step(i) + const rune = r >> 3 + const width = r & 7 + + if (width === 0) break + + const context = Utils.emptyOpContext(prevRune, rune) + currentState = this.step(currentState, rune, anchor, context) + + if (currentState === null) return null + + prevRune = rune + i += width + checkMatch(currentState, i, prevRune) + + if (currentState.nfaStates.length === 0) { + if (anchor !== RE2Flags.UNANCHORED) break + } + } + + return Array.from(matches).sort((a, b) => a - b) + } +} + +export { DFA } diff --git a/packages/cel/src/re2/Inst.ts b/packages/cel/src/re2/Inst.ts new file mode 100644 index 0000000..cb3cec1 --- /dev/null +++ b/packages/cel/src/re2/Inst.ts @@ -0,0 +1,90 @@ +import { RE2Flags } from './RE2Flags' +import { Unicode } from './Unicode' +/** + * A single instruction in the regular expression virtual machine. + * + * @see http://swtch.com/~rsc/regexp/regexp2.html + */ +class Inst { + static ALT = 1 + static ALT_MATCH = 2 + static CAPTURE = 3 + static EMPTY_WIDTH = 4 + static FAIL = 5 + static MATCH = 6 + static NOP = 7 + static RUNE = 8 + static RUNE1 = 9 + static RUNE_ANY = 10 + static RUNE_ANY_NOT_NL = 11 + + op: number + out: number + arg: number + runes: number[] + + static isRuneOp(op: number): boolean { + return Inst.RUNE <= op && op <= Inst.RUNE_ANY_NOT_NL + } + + constructor(op: number) { + this.op = op + this.out = 0 // all but MATCH, FAIL + this.arg = 0 // ALT, ALT_MATCH, CAPTURE, EMPTY_WIDTH + // length==1 => exact match + // otherwise a list of [lo,hi] pairs. hi is *inclusive*. + this.runes = [] + } + + // MatchRune returns true if the instruction matches (and consumes) r. + // It should only be called when op is a rune op. + matchRune(r: number): boolean { + // Special case: single-rune slice is from literal string, not char + // class. + if (this.runes.length === 1) { + const r0 = this.runes[0] + // If this pattern is case-insensitive, apply Unicode case folding to compare the two runes. + // Note that this may result in a case-folding loop when executed, + // so attempt to reduce the chance of that occurring + // by performing case folding on |r0| from the pattern rather than |r| from the input. + if ((this.arg & RE2Flags.FOLD_CASE) !== 0) { + return Unicode.equalsIgnoreCase(r0, r) + } + return r === r0 + } + + const len = this.runes.length + // If the array is exactly 2, 4, 6, or 8 items, DO NOT fall through to binary search + if (len === 2 || len === 4 || len === 6 || len === 8) { + for (let j = 0; j < len; j += 2) { + if (r < this.runes[j]) { + return false + } + if (r <= this.runes[j + 1]) { + return true + } + } + return false // Stop here + } + + // Otherwise binary search. + let lo = 0 + let hi = (this.runes.length / 2) | 0 + while (lo < hi) { + const m = (lo + hi) >> 1 // native cpu instruction for "lo + (((hi - lo) / 2) | 0)" + const c = this.runes[2 * m] + if (c <= r) { + if (r <= this.runes[2 * m + 1]) { + return true + } + lo = m + 1 + } else { + hi = m + } + } + + return false + } +} + +export { Inst } diff --git a/packages/cel/src/re2/MachineInput.ts b/packages/cel/src/re2/MachineInput.ts new file mode 100644 index 0000000..f8ef837 --- /dev/null +++ b/packages/cel/src/re2/MachineInput.ts @@ -0,0 +1,100 @@ +import { Utils } from './Utils' +import { Unicode } from './Unicode' + +/** + * MachineInput abstracts the input text supplied to the matching engine. + */ +class MachineInputBase { + end!: number + + static EOF(): number { + return -1 << 3 + } + + canCheckPrefix(): boolean { + return true + } + + endPos(): number { + return this.end + } + + hasString(prefilter?: any, pos?: number): boolean { + return false + } + + prefixLength(re2?: any): number { + return 0 + } +} + +// |pos| and |width| are in JS "char" units. +class MachineUTF16Input extends MachineInputBase { + charSequence: string + start: number + + constructor(charSequence: string, start = 0, end = charSequence.length) { + super() + this.charSequence = charSequence + this.start = start + this.end = end + } + + hasString(prefilter: any, pos: number): boolean { + const idx = this.charSequence.indexOf(prefilter.str, this.start + pos) + return idx !== -1 && idx <= this.end - prefilter.str.length + } + + step(pos: number): number { + pos += this.start + if (pos >= this.end) { + return MachineInputBase.EOF() + } + + const c1 = this.charSequence.charCodeAt(pos) + + // Fast path: standard BMP character (not a high surrogate) + if (c1 < Unicode.MIN_HIGH_SURROGATE || c1 > Unicode.MAX_HIGH_SURROGATE || pos + 1 >= this.end) { + return (c1 << 3) | 1 + } + + // Slow path: Calculate surrogate pair manually + const c2 = this.charSequence.charCodeAt(pos + 1) + if (c2 >= Unicode.MIN_LOW_SURROGATE && c2 <= Unicode.MAX_LOW_SURROGATE) { + const rune = + (c1 - Unicode.MIN_HIGH_SURROGATE) * 0x400 + + (c2 - Unicode.MIN_LOW_SURROGATE) + + Unicode.MIN_SUPPLEMENTARY_CODE_POINT + return (rune << 3) | 2 + } + + // Invalid surrogate pair fallback + return (c1 << 3) | 1 + } + + index(re2: any, pos: number): number { + pos += this.start + const i = this.charSequence.indexOf(re2.prefix, pos) + return i < 0 ? i : i - pos + } + + context(pos: number): number { + pos += this.start + const r1 = + pos > 0 && pos <= this.charSequence.length ? this.charSequence.codePointAt(pos - 1)! : -1 + const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos)! : -1 + return Utils.emptyOpContext(r1, r2) + } + + prefixLength(re2: any): number { + return re2.prefix.length + } +} + +class MachineInput { + static fromUTF16(charSequence: string, start = 0, end = charSequence.length): MachineUTF16Input { + return new MachineUTF16Input(charSequence, start, end) + } +} + +export { MachineInputBase, MachineInput } diff --git a/packages/cel/src/re2/Parser.ts b/packages/cel/src/re2/Parser.ts new file mode 100644 index 0000000..3eef00a --- /dev/null +++ b/packages/cel/src/re2/Parser.ts @@ -0,0 +1,1587 @@ +import { RE2Flags } from './RE2Flags' +import { Unicode } from './Unicode' +import { UnicodeTables } from './UnicodeTables' +import { UnicodeRangeTable } from './UnicodeRangeTable' +import { getPerlGroups, getPosixGroups } from './CharGroup' +import { Utils } from './Utils' +import { CharClass } from './CharClass' +import { RE2JSSyntaxException } from './exceptions' +import { Regexp } from './Regexp' + +// StringIterator: a stream of runes with an opaque cursor, permitting +// rewinding. The units of the cursor are not specified beyond the +// fact that ASCII characters are single width. (Cursor positions +// could be UTF-8 byte indices, UTF-16 code indices or rune indices.) +// +// In particular, be careful with: +// - skip: only use this to advance over ASCII characters +// since these always have a width of 1. +// - skipString: only use this to advance over strings which are +// known to be at the current position, e.g. due to prior call to +// lookingAt(). +// Only use pop() to advance over possibly non-ASCII runes. +class StringIterator { + str: string + position: number + + constructor(str: string) { + this.str = str + this.position = 0 + } + + // Returns the cursor position. Do not interpret the result! + pos(): number { + return this.position + } + + // Resets the cursor position to a previous value returned by pos(). + rewindTo(pos: number): void { + this.position = pos + } + + // Returns true unless the stream is exhausted. + more(): boolean { + return this.position < this.str.length + } + + // Returns the rune at the cursor position. + // Precondition: |more()|. + peek(): number { + return this.str.codePointAt(this.position)! + } + + // Advances the cursor by |n| positions, which must be ASCII runes. + // + // (In practise, this is only ever used to skip over regexp + // metacharacters that are ASCII, so there is no numeric difference + // between indices into UTF-8 bytes, UTF-16 codes and runes.) + skip(n: number): void { + this.position += n + } + + // Advances the cursor by the number of cursor positions in |s|. + skipString(s: string): void { + this.position += s.length + } + + // Returns the rune at the cursor position, and advances the cursor + // past it. Precondition: |more()|. + pop(): number { + const r = this.str.codePointAt(this.position)! + this.position += Utils.charCount(r) + return r + } + + lookingAt(s: string): boolean { + return this.str.startsWith(s, this.position) + } + + // Returns the rest of the pattern from the current position. + rest(): string { + return this.str.substring(this.position) + } + + // Returns the substring from |beforePos| to the current position. + // |beforePos| must have been previously returned by |pos()|. + from(beforePos: number): string { + return this.str.substring(beforePos, this.position) + } + + toString(): string { + return this.rest() + } +} +/** + * A parser of regular expression patterns. + * + * The only public entry point is {@link #parse(String pattern, int flags)}. + */ +class Parser { + // Unexpected error + static ERR_INTERNAL_ERROR = 'regexp/syntax: internal error' + + // Parse errors + static ERR_INVALID_CHAR_RANGE = 'invalid character class range' + static ERR_INVALID_ESCAPE = 'invalid escape sequence' + static ERR_INVALID_NAMED_CAPTURE = 'invalid named capture' + static ERR_INVALID_PERL_OP = 'invalid or unsupported Perl syntax' + static ERR_INVALID_REPEAT_OP = 'invalid nested repetition operator' + static ERR_INVALID_REPEAT_SIZE = 'invalid repeat count' + static ERR_MISSING_BRACKET = 'missing closing ]' + static ERR_MISSING_PAREN = 'missing closing )' + static ERR_MISSING_REPEAT_ARGUMENT = 'missing argument to repetition operator' + static ERR_TRAILING_BACKSLASH = 'trailing backslash at end of expression' + static ERR_DUPLICATE_NAMED_CAPTURE = 'duplicate capture group name' + static ERR_UNEXPECTED_PAREN = 'unexpected )' + static ERR_NESTING_DEPTH = 'expression nests too deeply' + static ERR_LARGE = 'expression too large' + + // maxHeight is the maximum height of a regexp parse tree. + // It is somewhat arbitrarily chosen, but the idea is to be large enough + // that no one will actually hit in real use but at the same time small enough + // that recursion on the Regexp tree will not hit the 1GB Go stack limit. + // The maximum amount of stack for a single recursive frame is probably + // closer to 1kB, so this could potentially be raised, but it seems unlikely + // that people have regexps nested even this deeply. + // We ran a test on Google's C++ code base and turned up only + // a single use case with depth > 100; it had depth 128. + // Using depth 1000 should be plenty of margin. + // As an optimization, we don't even bother calculating heights + // until we've allocated at least maxHeight Regexp structures. + static MAX_HEIGHT = 1000 + + // maxSize is the maximum size of a compiled regexp in Insts. + // It too is somewhat arbitrarily chosen, but the idea is to be large enough + // to allow significant regexps while at the same time small enough that + // the compiled form will not take up too much memory. + // 128 MB is enough for a 3.3 million Inst structures, which roughly + // corresponds to a 3.3 MB regexp. + static MAX_SIZE = 3355443 // 128 << 20 / (5 * 8) (instSize = byte, 2 uint32, slice is 5 64-bit words) + + // maxRunes is the maximum number of runes allowed in a regexp tree + // counting the runes in all the nodes. + // Ignoring character classes p.numRunes is always less than the length of the regexp. + // Character classes can make it much larger: each \pL adds 1292 runes. + // 128 MB is enough for 32M runes, which is over 26k \pL instances. + // Note that repetitions do not make copies of the rune slices, + // so \pL{1000} is only one rune slice, not 1000. + // We could keep a cache of character classes we've seen, + // so that all the \pL we see use the same rune list, + // but that doesn't remove the problem entirely: + // consider something like [\pL01234][\pL01235][\pL01236]...[\pL^&*()]. + // And because the Rune slice is exposed directly in the Regexp, + // there is not an opportunity to change the representation to allow + // partial sharing between different character classes. + // So the limit is the best we can do. + static MAX_RUNES = 33554432 // 128 << 20 / 4 (runeSize, int32 is 4 bytes) + + // RangeTables are represented as int[][], a list of triples (start, end, + // stride). + static ANY_TABLE = new UnicodeRangeTable(new Uint32Array([0, Unicode.MAX_RUNE, 1])) + + // Ascii tables + static ASCII_TABLE = new UnicodeRangeTable(new Uint32Array([0, 0x7f, 1])) + static ASCII_FOLD_TABLE = new UnicodeRangeTable( + new Uint32Array([ + 0, + 0x7f, + 1, + 0x017f, + 0x017f, + 1, // Old English long s (ſ), folds to S/s. + 0x212a, + 0x212a, + 1 // Kelvin K, folds to K/k. + ]) + ) + + // unicodeTable() returns the Unicode RangeTable identified by name + // and the table of additional fold-equivalent code points. + // Returns null if |name| does not identify a Unicode character range. + static unicodeTable(name: string): { tab: any; fold: any; sign: number } | null { + if (name === 'Any') { + return { tab: Parser.ANY_TABLE, fold: Parser.ANY_TABLE, sign: +1 } + } + if (name === 'Ascii') { + return { tab: Parser.ASCII_TABLE, fold: Parser.ASCII_FOLD_TABLE, sign: +1 } + } + if (name === 'Assigned') { + // Assigned is the mathematical inversion of Cn (Unassigned) + return { + tab: UnicodeTables.CATEGORIES.get('Cn'), + fold: UnicodeTables.CATEGORIES.get('Cn'), + sign: -1 + } + } + if (name === 'Lc') { + return { + tab: UnicodeTables.CATEGORIES.get('LC'), + fold: UnicodeTables.FOLD_CATEGORIES.get('LC'), + sign: +1 + } + } + if (UnicodeTables.CATEGORIES.has(name)) { + return { + tab: UnicodeTables.CATEGORIES.get(name), + fold: UnicodeTables.FOLD_CATEGORIES.get(name), + sign: +1 + } + } + if (UnicodeTables.SCRIPTS.has(name)) { + return { + tab: UnicodeTables.SCRIPTS.get(name), + fold: UnicodeTables.FOLD_SCRIPT.get(name), + sign: +1 + } + } + return null + } + + // minFoldRune returns the minimum rune fold-equivalent to r. + static minFoldRune(r: number): number { + if (r < Unicode.MIN_FOLD || r > Unicode.MAX_FOLD) { + return r + } + + let min = r + const r0 = r + for (r = Unicode.simpleFold(r); r !== r0; r = Unicode.simpleFold(r)) { + if (min > r) { + min = r + } + } + return min + } + + static literalRegexp(s: string, flags: number): Regexp { + const re = new Regexp(Regexp.Op.LITERAL) + re.flags = flags + re.runes = Utils.stringToRunes(s) as number[] + return re + } + /** + * Parse regular expression pattern {@code pattern} with mode flags {@code flags}. + * @param {string} pattern + * @param {number} flags + */ + static parse(pattern: string, flags: number): Regexp { + return new Parser(pattern, flags).parseInternal() + } + + // parseRepeat parses {min} (max=min) or {min,} (max=-1) or {min,max}. + // If |t| is not of that form, it returns -1. + // If |t| has the right form but the values are negative or too big, + // it returns -2. + // On success, returns a nonnegative number encoding min/max in the + // high/low signed halfwords of the result. (Note: min >= 0; max may + // be -1.) + // + // On success, advances |t| beyond the repeat; otherwise |t.pos()| is + // undefined. + static parseRepeat(t: StringIterator): number { + const start = t.pos() + if (!t.more() || !t.lookingAt('{')) { + return -1 + } + t.skip(1) + + const min = Parser.parseInt(t) + if (min === -1) { + return -1 + } + if (!t.more()) { + return -1 + } + + let max + if (!t.lookingAt(',')) { + max = min + } else { + t.skip(1) + if (!t.more()) { + return -1 + } + if (t.lookingAt('}')) { + max = -1 + } else if ((max = Parser.parseInt(t)) === -1) { + return -1 + } + } + + if (!t.more() || !t.lookingAt('}')) { + return -1 + } + t.skip(1) + if (min < 0 || min > 1000 || max === -2 || max > 1000 || (max >= 0 && min > max)) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_SIZE, t.from(start)) + } + + return (min << 16) | (max & Unicode.MAX_BMP) + } + + // isValidCaptureName reports whether name + // is a valid capture name: [A-Za-z0-9_]+. + // PCRE limits names to 32 bytes. + // Python rejects names starting with digits. + // We don't enforce either of those. + static isValidCaptureName(name: string): boolean { + if (name.length === 0) { + return false + } + + for (let i = 0; i < name.length; i++) { + const c = name.codePointAt(i)! + if (c !== 0x5f && !Utils.isalnum(c)) { + return false + } + } + + return true + } + + // parseInt parses a nonnegative decimal integer. + // -1 => bad format. -2 => format ok, but integer overflow. + static parseInt(t: StringIterator): number { + const start = t.pos() + while (t.more() && t.peek()! >= 0x30 && t.peek()! <= 0x39) { + t.skip(1) + } + + const n = t.from(start) + if (n.length === 0 || (n.length > 1 && n.codePointAt(0) === 0x30)) { + return -1 + } + if (n.length > 8) { + return -2 + } + return parseInt(n, 10) + } + + // can this be represented as a character class? + // single-rune literal string, char class, ., and .|\n. + static isCharClass(re: Regexp): boolean { + return ( + (re.op === Regexp.Op.LITERAL && re.runes.length === 1) || + re.op === Regexp.Op.CHAR_CLASS || + re.op === Regexp.Op.ANY_CHAR_NOT_NL || + re.op === Regexp.Op.ANY_CHAR + ) + } + + // does re match r? + static matchRune(re: Regexp, r: number): boolean { + switch (re.op) { + case Regexp.Op.LITERAL: + return re.runes.length === 1 && re.runes[0] === r + case Regexp.Op.CHAR_CLASS: + for (let i = 0; i < re.runes.length; i += 2) { + if (re.runes[i] <= r && r <= re.runes[i + 1]) { + return true + } + } + return false + case Regexp.Op.ANY_CHAR_NOT_NL: + return r !== 0x0a + case Regexp.Op.ANY_CHAR: + return true + } + return false + } + + // mergeCharClass makes dst = dst|src. + // The caller must ensure that dst.Op >= src.Op, + // to reduce the amount of copying. + static mergeCharClass(dst: Regexp, src: Regexp): void { + switch (dst.op) { + case Regexp.Op.ANY_CHAR: + break + case Regexp.Op.ANY_CHAR_NOT_NL: + if (Parser.matchRune(src, 0x0a)) { + dst.op = Regexp.Op.ANY_CHAR + } + break + case Regexp.Op.CHAR_CLASS: + if (src.op === Regexp.Op.LITERAL) { + dst.runes = new CharClass(dst.runes).appendLiteral(src.runes[0], src.flags).toArray() + } else { + dst.runes = new CharClass(dst.runes).appendClass(src.runes).toArray() + } + break + case Regexp.Op.LITERAL: + if (src.runes[0] === dst.runes[0] && src.flags === dst.flags) { + break + } + dst.op = Regexp.Op.CHAR_CLASS + dst.runes = new CharClass() + .appendLiteral(dst.runes[0], dst.flags) + .appendLiteral(src.runes[0], src.flags) + .toArray() + break + } + } + + // parseEscape parses an escape sequence at the beginning of s + // and returns the rune. + // Pre: t at '\\'. Post: after escape. + static parseEscape(t: StringIterator): number { + const startPos = t.pos() + t.skip(1) // '\\' + if (!t.more()) { + throw new RE2JSSyntaxException(Parser.ERR_TRAILING_BACKSLASH) + } + let c = t.pop() + bigswitch: switch (c) { + case 0x31: + case 0x32: + case 0x33: + case 0x34: + case 0x35: + case 0x36: + case 0x37: { + if (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37) { + break + } + } + // eslint-disable-next-line no-fallthrough + case 0x30: { + let r = c - 0x30 + for (let i = 1; i < 3; i++) { + if (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37) { + break + } + r = r * 8 + t.peek()! - 0x30 + t.skip(1) + } + return r + } + case 0x78: { + if (!t.more()) { + break + } + c = t.pop() + if (c === 0x7b) { + let nhex = 0 + let r = 0 + + while (true) { + if (!t.more()) { + break bigswitch + } + c = t.pop() + if (c === 0x7d) { + break + } + const v = Utils.unhex(c) + if (v < 0) { + break bigswitch + } + r = r * 16 + v + if (r > Unicode.MAX_RUNE) { + break bigswitch + } + nhex++ + } + if (nhex === 0) { + break bigswitch + } + return r + } + const x = Utils.unhex(c) + if (!t.more()) { + break + } + c = t.pop() + const y = Utils.unhex(c) + if (x < 0 || y < 0) { + break + } + return x * 16 + y + } + case 0x61: + return 0x07 + case 0x66: + return 0x0c + case 0x6e: + return 0x0a + case 0x72: + return 0x0d + case 0x74: + return 0x09 + case 0x76: + return 0x0b + default: + if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) { + return c + } + break + } + throw new RE2JSSyntaxException(Parser.ERR_INVALID_ESCAPE, t.from(startPos)) + } + + // parseClassChar parses a character class character and returns it. + // wholeClassPos is the position of the start of the entire class "[...". + // Pre: t at class char; Post: t after it. + static parseClassChar(t: StringIterator, wholeClassPos: number): number { + if (!t.more()) { + throw new RE2JSSyntaxException(Parser.ERR_MISSING_BRACKET, t.from(wholeClassPos)) + } + if (t.lookingAt('\\')) { + return Parser.parseEscape(t) + } + return t.pop() + } + + static concatRunes(x: number[], y: number[]): number[] { + const r = new Array(x.length + y.length) + for (let i = 0; i < x.length; i++) r[i] = x[i] + for (let i = 0; i < y.length; i++) r[x.length + i] = y[i] + return r + } + + wholeRegexp: string + flags: number + numCap: number + namedGroups: any + stack: any[] + free: any + numRegexp: number + numRunes: number + repeats: number + height: Map | null + size: Map | null + + constructor(wholeRegexp: string, flags = 0) { + this.wholeRegexp = wholeRegexp + // Flags control the behavior of the parser and record information about + // regexp context. + this.flags = flags + // number of capturing groups seen + this.numCap = 0 + this.namedGroups = Object.create(null) + // Stack of parsed expressions. + this.stack = [] + this.free = null + // checks + this.numRegexp = 0 // number of regexps allocated + this.numRunes = 0 // number of runes in char classes + this.repeats = 0 // product of all repetitions seen + this.height = null // regexp height, for height limit check + this.size = null // regexp compiled size, for size limit check + } + + // Allocate a Regexp, from the free list if possible. + newRegexp(op: number): Regexp { + let re = this.free + if (re !== null && re.subs !== null && re.subs.length > 0) { + this.free = re.subs[0] + re.reinit() + re.op = op + } else { + re = new Regexp(op) + this.numRegexp += 1 + } + return re + } + + reuse(re: Regexp): void { + if (this.height !== null) { + this.height.delete(re) + } + if (re.subs !== null && re.subs.length > 0) { + re.subs[0] = this.free + } + this.free = re + } + + checkLimits(re: Regexp): void { + if (this.numRunes > Parser.MAX_RUNES) { + throw new RE2JSSyntaxException(Parser.ERR_LARGE) + } + this.checkSize(re) + this.checkHeight(re) + } + + checkSize(re: Regexp): void { + if (this.size === null) { + // We haven't started tracking size yet. + // Do a relatively cheap check to see if we need to start. + // Maintain the product of all the repeats we've seen + // and don't track if the total number of regexp nodes + // we've seen times the repeat product is in budget. + if (this.repeats === 0) { + this.repeats = 1 + } + if (re.op === Regexp.Op.REPEAT) { + let n = re.max + if (n === -1) { + n = re.min + } + if (n <= 0) { + n = 1 + } + if (n > Parser.MAX_SIZE / this.repeats) { + this.repeats = Parser.MAX_SIZE + } else { + this.repeats *= n + } + } + if (this.numRegexp < Parser.MAX_SIZE / this.repeats) { + return + } + + // We need to start tracking size. + // Make the map and belatedly populate it + // with info about everything we've constructed so far. + this.size = new Map() + for (let reEx of this.stack) { + this.checkSize(reEx) + } + } + + if (this.calcSize(re, true) > Parser.MAX_SIZE) { + throw new RE2JSSyntaxException(Parser.ERR_LARGE) + } + } + + calcSize(re: Regexp, force = false): number { + if (!force && this.size!.has(re)) { + return this.size!.get(re)! + } + + let size = 0 + switch (re.op) { + case Regexp.Op.LITERAL: { + size = re.runes.length + break + } + case Regexp.Op.CAPTURE: + case Regexp.Op.STAR: { + // star can be 1+ or 2+; assume 2 pessimistically + size = 2 + this.calcSize(re.subs[0]) + break + } + case Regexp.Op.PLUS: + case Regexp.Op.QUEST: { + size = 1 + this.calcSize(re.subs[0]) + break + } + case Regexp.Op.CONCAT: { + for (let sub of re.subs) { + size = size + this.calcSize(sub) + } + break + } + case Regexp.Op.ALTERNATE: { + for (let sub of re.subs) { + size = size + this.calcSize(sub) + } + if (re.subs.length > 1) { + size = size + re.subs.length - 1 + } + break + } + case Regexp.Op.REPEAT: { + let sub = this.calcSize(re.subs[0]) + if (re.max === -1) { + if (re.min === 0) { + size = 2 + sub // x* + } else { + size = 1 + re.min * sub // xxx+ + } + break + } + // x{2,5} = xx(x(x(x)?)?)? + size = re.max * sub + (re.max - re.min) + break + } + } + + size = Math.max(1, size) + this.size!.set(re, size) + return size + } + + checkHeight(re: Regexp): void { + if (this.numRegexp < Parser.MAX_HEIGHT) { + return + } + if (this.height === null) { + this.height = new Map() + for (let reEx of this.stack) { + this.checkHeight(reEx) + } + } + if (this.calcHeight(re, true) > Parser.MAX_HEIGHT) { + throw new RE2JSSyntaxException(Parser.ERR_NESTING_DEPTH) + } + } + + calcHeight(re: Regexp, force = false): number { + if (!force && this.height!.has(re)) { + return this.height!.get(re)! + } + let h = 1 + for (let sub of re.subs) { + const hsub = this.calcHeight(sub) + if (h < 1 + hsub) { + h = 1 + hsub + } + } + this.height!.set(re, h) + return h + } + + // Parse stack manipulation. + + pop(): Regexp { + return this.stack.pop() + } + + popToPseudo(): Regexp[] { + const n = this.stack.length + let i = n + while (i > 0 && !Regexp.isPseudoOp(this.stack[i - 1].op)) { + i-- + } + + const r = this.stack.slice(i, n) + this.stack = this.stack.slice(0, i) + return r + } + + // push pushes the regexp re onto the parse stack and returns the regexp. + // Returns null for a CHAR_CLASS that can be merged with the top-of-stack. + push(re: Regexp): Regexp | null { + this.numRunes += re.runes.length + if (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 2 && re.runes[0] === re.runes[1]) { + if (this.maybeConcat(re.runes[0], this.flags & ~RE2Flags.FOLD_CASE)) { + return null + } + re.op = Regexp.Op.LITERAL + re.runes = [re.runes[0]] + re.flags = this.flags & ~RE2Flags.FOLD_CASE + } else if ( + (re.op === Regexp.Op.CHAR_CLASS && + re.runes.length === 4 && + re.runes[0] === re.runes[1] && + re.runes[2] === re.runes[3] && + Unicode.simpleFold(re.runes[0]) === re.runes[2] && + Unicode.simpleFold(re.runes[2]) === re.runes[0]) || + (re.op === Regexp.Op.CHAR_CLASS && + re.runes.length === 2 && + re.runes[0] + 1 === re.runes[1] && + Unicode.simpleFold(re.runes[0]) === re.runes[1] && + Unicode.simpleFold(re.runes[1]) === re.runes[0]) + ) { + // Case-insensitive rune like [Aa] or [Δδ]. + if (this.maybeConcat(re.runes[0], this.flags | RE2Flags.FOLD_CASE)) { + return null + } + // Rewrite as (case-insensitive) literal. + re.op = Regexp.Op.LITERAL + re.runes = [re.runes[0]] + re.flags = this.flags | RE2Flags.FOLD_CASE + } else { + // Incremental concatenation. + this.maybeConcat(-1, 0) + } + this.stack.push(re) + this.checkLimits(re) + return re + } + + // maybeConcat implements incremental concatenation + // of literal runes into string nodes. The parser calls this + // before each push, so only the top fragment of the stack + // might need processing. Since this is called before a push, + // the topmost literal is no longer subject to operators like * + // (Otherwise ab* would turn into (ab)*.) + // If (r >= 0 and there's a node left over, maybeConcat uses it + // to push r with the given flags. + // maybeConcat reports whether r was pushed. + maybeConcat(r: number, flags: number): boolean { + const n = this.stack.length + if (n < 2) { + return false + } + const re1 = this.stack[n - 1] + const re2 = this.stack[n - 2] + if ( + re1.op !== Regexp.Op.LITERAL || + re2.op !== Regexp.Op.LITERAL || + (re1.flags & RE2Flags.FOLD_CASE) !== (re2.flags & RE2Flags.FOLD_CASE) + ) { + return false + } + // Push re1 into re2. + re2.runes = Parser.concatRunes(re2.runes, re1.runes) + // Reuse re1 if possible. + if (r >= 0) { + re1.runes = [r] + re1.flags = flags + return true + } + this.pop() + this.reuse(re1) + return false // did not push r + } + + // newLiteral returns a new LITERAL Regexp with the given flags + newLiteral(r: number, flags: number): Regexp { + const re = this.newRegexp(Regexp.Op.LITERAL) + re.flags = flags + if ((flags & RE2Flags.FOLD_CASE) !== 0) { + r = Parser.minFoldRune(r) + } + re.runes = [r] + return re + } + + // literal pushes a literal regexp for the rune r on the stack + // and returns that regexp. + literal(r: number): void { + this.push(this.newLiteral(r, this.flags)) + } + + // op pushes a regexp with the given op onto the stack + // and returns that regexp. + op(op: number): Regexp | null { + const re = this.newRegexp(op) + re.flags = this.flags + return this.push(re) + } + + // repeat replaces the top stack element with itself repeated according to + // op, min, max. beforePos is the start position of the repetition operator. + // Pre: t is positioned after the initial repetition operator. + // Post: t advances past an optional perl-mode '?', or stays put. + // Or, it fails with RE2JSSyntaxException. + repeat( + op: number, + min: number, + max: number, + beforePos: number, + t: StringIterator, + lastRepeatPos: number + ): void { + let flags = this.flags + if (t.more() && t.lookingAt('?')) { + t.skip(1) + flags ^= RE2Flags.NON_GREEDY + } + if (lastRepeatPos !== -1) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_OP, t.from(lastRepeatPos)) + } + + const n = this.stack.length + if (n === 0) { + throw new RE2JSSyntaxException(Parser.ERR_MISSING_REPEAT_ARGUMENT, t.from(beforePos)) + } + + const sub = this.stack[n - 1] + if (Regexp.isPseudoOp(sub.op)) { + throw new RE2JSSyntaxException(Parser.ERR_MISSING_REPEAT_ARGUMENT, t.from(beforePos)) + } + + const re = this.newRegexp(op) + re.min = min + re.max = max + re.flags = flags + re.subs = [sub] + this.stack[n - 1] = re + + this.checkLimits(re) + + if (op === Regexp.Op.REPEAT && (min >= 2 || max >= 2) && !this.repeatIsValid(re, 1000)) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_SIZE, t.from(beforePos)) + } + } + + // repeatIsValid reports whether the repetition re is valid. + // Valid means that the combination of the top-level repetition + // and any inner repetitions does not exceed n copies of the + // innermost thing. + // This function rewalks the regexp tree and is called for every repetition, + // so we have to worry about inducing quadratic behavior in the parser. + // We avoid this by only calling repeatIsValid when min or max >= 2. + // In that case the depth of any >= 2 nesting can only get to 9 without + // triggering a parse error, so each subtree can only be rewalked 9 times. + repeatIsValid(re: Regexp, n: number): boolean { + if (re.op === Regexp.Op.REPEAT) { + let m = re.max + if (m === 0) { + return true + } + if (m < 0) { + m = re.min + } + if (m > n) { + return false + } + if (m > 0) { + n = Math.trunc(n / m) + } + } + + for (let sub of re.subs) { + if (!this.repeatIsValid(sub, n)) { + return false + } + } + + return true + } + + // concat replaces the top of the stack (above the topmost '|' or '(') with + // its concatenation. + concat(): Regexp | null { + this.maybeConcat(-1, 0) + const subs = this.popToPseudo() + if (subs.length === 0) { + return this.push(this.newRegexp(Regexp.Op.EMPTY_MATCH)) + } + return this.push(this.collapse(subs, Regexp.Op.CONCAT)) + } + + // alternate replaces the top of the stack (above the topmost '(') with its + // alternation. + alternate(): Regexp | null { + // Scan down to find pseudo-operator (. + // There are no | above (. + const subs = this.popToPseudo() + // Make sure top class is clean. + // All the others already are (see swapVerticalBar). + if (subs.length > 0) { + this.cleanAlt(subs[subs.length - 1]) + } + // Empty alternate is special case + // (shouldn't happen but easy to handle). + if (subs.length === 0) { + return this.push(this.newRegexp(Regexp.Op.NO_MATCH)) + } + return this.push(this.collapse(subs, Regexp.Op.ALTERNATE)) + } + + // cleanAlt cleans re for eventual inclusion in an alternation. + cleanAlt(re: Regexp): void { + if (re.op === Regexp.Op.CHAR_CLASS) { + re.runes = new CharClass(re.runes).cleanClass().toArray() + if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) { + re.runes = [] + re.op = Regexp.Op.ANY_CHAR + } else if ( + re.runes.length === 4 && + re.runes[0] === 0 && + re.runes[1] === 0x0a - 1 && + re.runes[2] === 0x0a + 1 && + re.runes[3] === Unicode.MAX_RUNE + ) { + re.runes = [] + re.op = Regexp.Op.ANY_CHAR_NOT_NL + } + } + } + + // collapse returns the result of applying op to subs[start:end]. + // If (sub contains op nodes, they all get hoisted up + // so that there is never a concat of a concat or an + // alternate of an alternate. + collapse(subs: Regexp[], op: number): Regexp { + if (subs.length === 1) { + return subs[0] + } + // Concatenate subs iff op is same. + // Compute length in first pass. + let len = 0 + for (let sub of subs) { + len += sub.op === op ? sub.subs.length : 1 + } + let newsubs = new Array(len).fill(null) + let i = 0 + for (let sub of subs) { + if (sub.op === op) { + for (let j = 0; j < sub.subs.length; j++) { + newsubs[i++] = sub.subs[j] + } + this.reuse(sub) + } else { + newsubs[i++] = sub + } + } + + let re = this.newRegexp(op) + re.subs = newsubs + if (op === Regexp.Op.ALTERNATE) { + if (re.subs.length === 1) { + const old = re + re = re.subs[0] + this.reuse(old) + } + } + return re + } + + parseInternal(): Regexp { + if ((this.flags & RE2Flags.LITERAL) !== 0) { + // Trivial parser for literal string. + return Parser.literalRegexp(this.wholeRegexp, this.flags) + } + // Otherwise, must do real work. + let lastRepeatPos = -1 + let min = -1 + let max = -1 + const t = new StringIterator(this.wholeRegexp) + while (t.more()) { + { + let repeatPos = -1 + bigswitch: switch (t.peek()) { + case 0x28: + if (t.lookingAt('(?')) { + // Flag changes and non-capturing groups. + this.parsePerlFlags(t) + break + } + this.op(Regexp.Op.LEFT_PAREN)!.cap = ++this.numCap + t.skip(1) // '(' + break + case 0x7c: + this.parseVerticalBar() // '|' + t.skip(1) // '|' + break + case 0x29: + this.parseRightParen() + t.skip(1) // ')' + break + case 0x5e: + if ((this.flags & RE2Flags.ONE_LINE) !== 0) { + this.op(Regexp.Op.BEGIN_TEXT) + } else { + this.op(Regexp.Op.BEGIN_LINE) + } + t.skip(1) // '^' + break + case 0x24: + if ((this.flags & RE2Flags.ONE_LINE) !== 0) { + this.op(Regexp.Op.END_TEXT)!.flags |= RE2Flags.WAS_DOLLAR + } else { + this.op(Regexp.Op.END_LINE) + } + t.skip(1) // '$' + break + case 0x2e: + if ((this.flags & RE2Flags.DOT_NL) !== 0) { + this.op(Regexp.Op.ANY_CHAR) + } else { + this.op(Regexp.Op.ANY_CHAR_NOT_NL) + } + t.skip(1) // '.' + break + case 0x5b: + this.parseClass(t) + break + case 0x2a: + case 0x2b: + case 0x3f: { + repeatPos = t.pos() + let op: number | null = null + switch (t.pop()) { + case 0x2a: + op = Regexp.Op.STAR + break + case 0x2b: + op = Regexp.Op.PLUS + break + case 0x3f: + op = Regexp.Op.QUEST + break + } + this.repeat(op!, min, max, repeatPos, t, lastRepeatPos) + // (min and max are now dead.) + break + } + + case 0x7b: { + repeatPos = t.pos() + const minMax = Parser.parseRepeat(t) + if (minMax < 0) { + // If the repeat cannot be parsed, { is a literal. + t.rewindTo(repeatPos) + this.literal(t.pop()) // '{' + break + } + min = minMax >> 16 + max = ((minMax & Unicode.MAX_BMP) << 16) >> 16 + this.repeat(Regexp.Op.REPEAT, min, max, repeatPos, t, lastRepeatPos) + break + } + + case 0x5c: { + const savedPos = t.pos() + t.skip(1) // '\\' + if (t.more()) { + const c = t.pop() + switch (c) { + case 0x41: + this.op(Regexp.Op.BEGIN_TEXT) + break bigswitch + case 0x62: + this.op(Regexp.Op.WORD_BOUNDARY) + break bigswitch + case 0x42: + this.op(Regexp.Op.NO_WORD_BOUNDARY) + break bigswitch + case 0x43: + // any byte; not supported + throw new RE2JSSyntaxException(Parser.ERR_INVALID_ESCAPE, '\\C') + case 0x51: { + // \Q ... \E: the ... is always literals + let lit = t.rest() + const i = lit.indexOf('\\E') + if (i >= 0) { + lit = lit.substring(0, i) + t.skipString(lit) + t.skipString('\\E') + } else { + t.skipString(lit) + } + + let j = 0 + while (j < lit.length) { + const codepoint = lit.codePointAt(j)! + this.literal(codepoint) + j += Utils.charCount(codepoint) + } + break bigswitch + } + + case 0x7a: + this.op(Regexp.Op.END_TEXT) + break bigswitch + default: + t.rewindTo(savedPos) + break + } + } else { + t.rewindTo(savedPos) + } + + const re = this.newRegexp(Regexp.Op.CHAR_CLASS) + re.flags = this.flags + // Look for Unicode character group like \p{Han} + if (t.lookingAt('\\p') || t.lookingAt('\\P')) { + const cc = new CharClass() + if (this.parseUnicodeClass(t, cc)) { + re.runes = cc.toArray() + this.push(re) + break bigswitch + } + } + // Perl character class escape. + const cc = new CharClass() + if (this.parsePerlClassEscape(t, cc)) { + re.runes = cc.toArray() + this.push(re) + break bigswitch + } + t.rewindTo(savedPos) + this.reuse(re) + // Ordinary single-character escape. + this.literal(Parser.parseEscape(t)) + break + } + default: + this.literal(t.pop()) + break + } + lastRepeatPos = repeatPos + } + } + + this.concat() + if (this.swapVerticalBar()) { + this.pop() // pop vertical bar + } + this.alternate() + const n = this.stack.length + if (n !== 1) { + throw new RE2JSSyntaxException(Parser.ERR_MISSING_PAREN, this.wholeRegexp) + } + this.stack[0].namedGroups = this.namedGroups + return this.stack[0] + } + + // parsePerlFlags parses a Perl flag setting or non-capturing group or both, + // like (?i) or (?: or (?i:. + // Pre: t at "(?". Post: t after ")". + // Sets numCap. + parsePerlFlags(t: StringIterator): void { + const startPos = t.pos() + // Check for named captures, first introduced in Python's regexp library. + // As usual, there are three slightly different syntaxes: + // + // (?Pexpr) the original, introduced by Python + // (?expr) the .NET alteration, adopted by Perl 5.10 + // (?'name'expr) another .NET alteration, adopted by Perl 5.10 + // + // Perl 5.10 gave in and implemented the Python version too, + // but they claim that the last two are the preferred forms. + // PCRE and languages based on it (specifically, PHP and Ruby) + // support all three as well. EcmaScript 4 uses only the Python form. + // + // In both the open source world (via Code Search) and the + // Google source tree, (?Pexpr) and (?expr) are the + // dominant forms of named captures and both are supported. + if (t.lookingAt('(?P<') || t.lookingAt('(?<')) { + // Pull out name. + const s = t.rest() + const begin = s.charAt(2) === 'P' ? 4 : 3 + const end = s.indexOf('>') + if (end < 0) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s) + } + const name = s.substring(begin, end) // "name" + t.skipString(name) + t.skip(begin + 1) // "(?P<>" or "(?<>" + if (!Parser.isValidCaptureName(name)) { + // "(?P" + throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s.substring(0, end + 1)) // "(?P" or "(?" + } + // Like ordinary capture, but named. + const re = this.op(Regexp.Op.LEFT_PAREN)! + re.cap = ++this.numCap + if (this.namedGroups[name]) { + throw new RE2JSSyntaxException(Parser.ERR_DUPLICATE_NAMED_CAPTURE, name) + } + this.namedGroups[name] = this.numCap + re.name = name + return + } + // Non-capturing group. Might also twiddle Perl flags. + t.skip(2) // "(?" + + let flags = this.flags + let sign = +1 + let sawFlag = false + loop: while (t.more()) { + { + const c = t.pop() + switch (c) { + case 0x69: + flags |= RE2Flags.FOLD_CASE + sawFlag = true + break + case 0x6d: + flags &= ~RE2Flags.ONE_LINE + sawFlag = true + break + case 0x73: + flags |= RE2Flags.DOT_NL + sawFlag = true + break + case 0x55: + flags |= RE2Flags.NON_GREEDY + sawFlag = true + break + // Switch to negation. + case 0x2d: + if (sign < 0) { + break loop + } + sign = -1 + // Invert flags so that | above turn into &~ and vice versa. + // We'll invert flags again before using it below. + flags = ~flags + sawFlag = false + break + // End of flags, starting group or not. + case 0x3a: + case 0x29: + if (sign < 0) { + if (!sawFlag) { + break loop + } + flags = ~flags + } + if (c === 0x3a) { + // Open new group + this.op(Regexp.Op.LEFT_PAREN) + } + this.flags = flags + return + default: + // Flags. + break loop + } + } + } + + throw new RE2JSSyntaxException(Parser.ERR_INVALID_PERL_OP, t.from(startPos)) + } + + // parseVerticalBar handles a | in the input. + parseVerticalBar(): void { + this.concat() + // The concatenation we just parsed is on top of the stack. + // If it sits above an opVerticalBar, swap it below + // (things below an opVerticalBar become an alternation). + // Otherwise, push a new vertical bar. + if (!this.swapVerticalBar()) { + this.op(Regexp.Op.VERTICAL_BAR) + } + } + + // If the top of the stack is an element followed by an opVerticalBar + // swapVerticalBar swaps the two and returns true. + // Otherwise it returns false. + swapVerticalBar(): boolean { + const n = this.stack.length + // If above and below vertical bar are literal or char class, + // can merge into a single char class. + if ( + n >= 3 && + this.stack[n - 2].op === Regexp.Op.VERTICAL_BAR && + Parser.isCharClass(this.stack[n - 1]) && + Parser.isCharClass(this.stack[n - 3]) + ) { + let re1 = this.stack[n - 1] + let re3 = this.stack[n - 3] + // Make re3 the more complex of the two. + if (re1.op > re3.op) { + const tmp = re3 + re3 = re1 + re1 = tmp + this.stack[n - 3] = re3 + } + Parser.mergeCharClass(re3, re1) + this.reuse(re1) + this.pop() + return true + } + if (n >= 2) { + const re1 = this.stack[n - 1] + const re2 = this.stack[n - 2] + if (re2.op === Regexp.Op.VERTICAL_BAR) { + if (n >= 3) { + // Now out of reach. + // Clean opportunistically. + this.cleanAlt(this.stack[n - 3]) + } + this.stack[n - 2] = re1 + this.stack[n - 1] = re2 + return true + } + } + return false + } + + // parseRightParen handles a ')' in the input. + parseRightParen(): void { + this.concat() + if (this.swapVerticalBar()) { + this.pop() // pop vertical bar + } + this.alternate() + const n = this.stack.length + if (n < 2) { + throw new RE2JSSyntaxException(Parser.ERR_UNEXPECTED_PAREN, this.wholeRegexp) + } + + const re1 = this.pop() + const re2 = this.pop() + if (re2.op !== Regexp.Op.LEFT_PAREN) { + throw new RE2JSSyntaxException(Parser.ERR_UNEXPECTED_PAREN, this.wholeRegexp) + } + // Restore flags at time of paren. + this.flags = re2.flags + if (re2.cap === 0) { + // Just for grouping. + this.push(re1) + } else { + re2.op = Regexp.Op.CAPTURE + re2.subs = [re1] + this.push(re2) + } + } + + // parsePerlClassEscape parses a leading Perl character class escape like \d + // from the beginning of |t|. If one is present, it appends the characters + // to cc and returns true. The iterator is advanced past the escape + // on success, undefined on failure, in which case false is returned. + parsePerlClassEscape(t: StringIterator, cc: CharClass): boolean { + const beforePos = t.pos() + if (!t.more() || t.pop() !== 0x5c || !t.more()) { + return false + } + t.pop() // e.g. advance past 'd' in "\\d" + const p = t.from(beforePos) + const perlGroups = getPerlGroups() + const g = perlGroups.has(p) ? perlGroups.get(p) : null + if (g === null) { + return false + } + cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0) + return true + } + + // parseNamedClass parses a leading POSIX named character class like + // [:alnum:] from the beginning of t. If one is present, it appends the + // characters to cc, advances the iterator, and returns true. + // Pre: t at "[:". Post: t after ":]". + // On failure (no class of than name), throws RE2JSSyntaxException. + // On misparse, returns false; t.pos() is undefined. + parseNamedClass(t: StringIterator, cc: CharClass): boolean { + // (Go precondition check deleted.) + const cls = t.rest() + const i = cls.indexOf(':]') + if (i < 0) { + return false + } + + const name = cls.substring(0, i + 2) // "[:alnum:]" + t.skipString(name) + const posixGroups = getPosixGroups() + const g = posixGroups.has(name) ? posixGroups.get(name) : null + if (g === null) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, name) + } + cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0) + return true + } + + // parseUnicodeClass() parses a leading Unicode character class like \p{Han} + // from the beginning of t. If one is present, it appends the characters to + // to |cc|, advances |t| and returns true. + // + // Returns false if such a pattern is not present or UNICODE_GROUPS + // flag is not enabled; |t.pos()| is not advanced in this case. + // Indicates error by throwing RE2JSSyntaxException. + parseUnicodeClass(t: StringIterator, cc: CharClass): boolean { + const startPos = t.pos() + if ( + (this.flags & RE2Flags.UNICODE_GROUPS) === 0 || + (!t.lookingAt('\\p') && !t.lookingAt('\\P')) + ) { + return false + } + + t.skip(1) // '\\' + // Committed to parse or throw exception. + let sign = +1 + let c = t.pop() // 'p' or 'P' + if (c === 0x50) { + sign = -1 + } + if (!t.more()) { + t.rewindTo(startPos) + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.rest()) + } + + c = t.pop() + let name + + if (c !== 0x7b) { + // Single-letter name. + name = Utils.runeToString(c) + } else { + // Name is in braces. + const rest = t.rest() + const end = rest.indexOf('}') + if (end < 0) { + t.rewindTo(startPos) + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.rest()) + } + name = rest.substring(0, end) // e.g. "Han" + t.skipString(name) + t.skip(1) + // Don't use skip(end) because it assumes UTF-16 coding, and + // StringIterator doesn't guarantee that. + } + // Group can have leading negation too. + // \p{^Han} == \P{Han}, \P{^Han} == \p{Han}. + if (!(name.length === 0) && name.codePointAt(0) === 0x5e) { + sign = 0 - sign // -sign + name = name.substring(1) + } + + const pair = Parser.unicodeTable(name) + if (pair === null) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.from(startPos)) + } + if (pair.sign < 0) { + sign = 0 - sign + } + + const tab = pair.tab + const fold = pair.fold // fold-equivalent table + // Variation of CharClass.appendGroup() for tables. + if ((this.flags & RE2Flags.FOLD_CASE) === 0 || fold === null) { + cc.appendTableWithSign(tab, sign) + } else { + // Merge and clean tab and fold in a temporary buffer. + // This is necessary for the negative case and just tidy + // for the positive case. + const tmp = new CharClass().appendTable(tab).appendTable(fold).cleanClass().toArray() + cc.appendClassWithSign(tmp, sign) + } + return true + } + + // parseClass parses a character class and pushes it onto the parse stack. + // + // NOTES: + // Pre: at '['; Post: after ']'. + // Mutates stack. Advances iterator. May throw. + parseClass(t: StringIterator): void { + const startPos = t.pos() + t.skip(1) // '[' + const re = this.newRegexp(Regexp.Op.CHAR_CLASS) + re.flags = this.flags + const cc = new CharClass() + let sign = +1 + + if (t.more() && t.lookingAt('^')) { + sign = -1 + t.skip(1) // '^' + // If character class does not match \n, add it here, + // so that negation later will do the right thing. + if ((this.flags & RE2Flags.CLASS_NL) === 0) { + cc.appendRange(0x0a, 0x0a) + } + } + + let first = true // ']' and '-' are okay as first char in class + while (!t.more() || t.peek() !== 0x5d || first) { + first = false + const beforePos = t.pos() + // Look for POSIX [:alnum:] etc. + if (t.lookingAt('[:')) { + if (this.parseNamedClass(t, cc)) { + continue + } + t.rewindTo(beforePos) + } + + // Look for Unicode character group like \p{Han}. + if (this.parseUnicodeClass(t, cc)) { + continue + } + + // Look for Perl character class symbols (extension). + if (this.parsePerlClassEscape(t, cc)) { + continue + } + t.rewindTo(beforePos) + + // Single character or simple range. + const lo = Parser.parseClassChar(t, startPos) + let hi = lo + if (t.more() && t.lookingAt('-')) { + t.skip(1) + if (t.more() && t.lookingAt(']')) { + // [a-] means (a|-) so check for final ]. + t.skip(-1) + } else { + hi = Parser.parseClassChar(t, startPos) + if (hi < lo) { + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.from(beforePos)) + } + } + } + if ((this.flags & RE2Flags.FOLD_CASE) === 0) { + cc.appendRange(lo, hi) + } else { + cc.appendFoldedRange(lo, hi) + } + } + t.skip(1) // ']' + + cc.cleanClass() + if (sign < 0) { + cc.negateClass() + } + re.runes = cc.toArray() + this.push(re) + } +} + +export { Parser } diff --git a/packages/cel/src/re2/Prefilter.ts b/packages/cel/src/re2/Prefilter.ts new file mode 100644 index 0000000..817df22 --- /dev/null +++ b/packages/cel/src/re2/Prefilter.ts @@ -0,0 +1,173 @@ +import { Regexp } from './Regexp' + +import { RE2Flags } from './RE2Flags' + +class Prefilter { + type: number + subs: any[] + str: string + + static Type = { NONE: 0, EXACT: 1, AND: 2, OR: 3 } + + constructor(type: number) { + this.type = type + this.subs = [] + this.str = '' + } + + eval(input: any, pos: number): boolean { + switch (this.type) { + case Prefilter.Type.NONE: + return true + case Prefilter.Type.EXACT: + return input.hasString(this, pos) + case Prefilter.Type.AND: + for (let i = 0; i < this.subs.length; i++) { + if (!this.subs[i].eval(input, pos)) return false + } + return true + case Prefilter.Type.OR: + for (let i = 0; i < this.subs.length; i++) { + if (this.subs[i].eval(input, pos)) return true + } + return false + default: + return true + } + } +} + +class PrefilterTree { + static build(re: Regexp): Prefilter { + const pf = PrefilterTree.fromRegexp(re) + return PrefilterTree.simplify(pf) + } + + static fromRegexp(re: Regexp): Prefilter { + if (!re) return new Prefilter(Prefilter.Type.NONE) + + switch (re.op) { + case Regexp.Op.NO_MATCH: + case Regexp.Op.EMPTY_MATCH: + case Regexp.Op.BEGIN_LINE: + case Regexp.Op.END_LINE: + case Regexp.Op.BEGIN_TEXT: + case Regexp.Op.END_TEXT: + case Regexp.Op.WORD_BOUNDARY: + case Regexp.Op.NO_WORD_BOUNDARY: + case Regexp.Op.CHAR_CLASS: + case Regexp.Op.ANY_CHAR_NOT_NL: + case Regexp.Op.ANY_CHAR: { + return new Prefilter(Prefilter.Type.NONE) + } + + case Regexp.Op.LITERAL: { + if (re.runes.length === 0 || (re.flags & RE2Flags.FOLD_CASE) !== 0) { + // Skip case-folded literals for simplicity + return new Prefilter(Prefilter.Type.NONE) + } + const pf = new Prefilter(Prefilter.Type.EXACT) + let str = '' + for (let i = 0; i < re.runes.length; i++) { + str += String.fromCodePoint(re.runes[i]) + } + pf.str = str + return pf + } + + case Regexp.Op.CAPTURE: + case Regexp.Op.PLUS: { + return PrefilterTree.fromRegexp(re.subs[0]) + } + + case Regexp.Op.REPEAT: { + if (re.min >= 1) { + return PrefilterTree.fromRegexp(re.subs[0]) + } + return new Prefilter(Prefilter.Type.NONE) + } + + case Regexp.Op.CONCAT: { + const pf = new Prefilter(Prefilter.Type.AND) + for (const sub of re.subs) { + pf.subs.push(PrefilterTree.fromRegexp(sub)) + } + return pf + } + + case Regexp.Op.ALTERNATE: { + const pf = new Prefilter(Prefilter.Type.OR) + for (const sub of re.subs) { + pf.subs.push(PrefilterTree.fromRegexp(sub)) + } + return pf + } + + default: + return new Prefilter(Prefilter.Type.NONE) + } + } + + static simplify(pf: Prefilter): Prefilter { + if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) { + return pf + } + + if (pf.type === Prefilter.Type.AND) { + const newSubs = [] + for (const sub of pf.subs) { + const s = PrefilterTree.simplify(sub) + if (s.type !== Prefilter.Type.NONE) { + if (s.type === Prefilter.Type.AND) { + newSubs.push(...s.subs) + } else { + newSubs.push(s) + } + } + } + + if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE) + if (newSubs.length === 1) return newSubs[0] + pf.subs = newSubs + return pf + } + + if (pf.type === Prefilter.Type.OR) { + const newSubs = [] + for (const sub of pf.subs) { + const s = PrefilterTree.simplify(sub) + if (s.type === Prefilter.Type.NONE) { + // If any branch of an OR has no requirements, the whole OR has no requirements + return new Prefilter(Prefilter.Type.NONE) + } + if (s.type === Prefilter.Type.OR) { + newSubs.push(...s.subs) + } else { + newSubs.push(s) + } + } + if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE) + if (newSubs.length === 1) return newSubs[0] + + // De-duplicate EXACT branches + const seen = new Set() + const uniqueSubs = [] + for (const sub of newSubs) { + if (sub.type === Prefilter.Type.EXACT) { + if (!seen.has(sub.str)) { + seen.add(sub.str) + uniqueSubs.push(sub) + } + } else { + uniqueSubs.push(sub) + } + } + pf.subs = uniqueSubs + return pf + } + + return pf + } +} + +export { Prefilter, PrefilterTree } diff --git a/packages/cel/src/re2/Prog.ts b/packages/cel/src/re2/Prog.ts new file mode 100644 index 0000000..dab187e --- /dev/null +++ b/packages/cel/src/re2/Prog.ts @@ -0,0 +1,168 @@ +import { RE2Flags } from './RE2Flags' +import { Inst } from './Inst' + +/** + * A list of instruction pointers waiting to be patched. + * Tracks both `head` and `tail` to allow O(1) appending during compilation. + * * Values are encoded integers, not standard memory pointers: + * - Program instruction index: `l >> 1` + * - Patch `.out` field if: `(l & 1) === 0` + * - Patch `.arg` field if: `(l & 1) === 1` + * - `0` denotes an empty list. + * * @see https://swtch.com/~rsc/regexp/regexp1.html + */ +class PatchList { + head: number + tail: number + + /** + * @param {number} head - Encoded pointer to the start of the patch list. + * @param {number} tail - Encoded pointer to the end of the patch list. + */ + constructor(head = 0, tail = 0) { + this.head = head + this.tail = tail + } +} + +/** + * A Prog is a compiled regular expression program. + */ +class Prog { + inst: any[] + start: number + numCap: number + + constructor() { + this.inst = [] + this.start = 0 // index of start instruction + // number of CAPTURE insts in re + // 2 => implicit ( and ) for whole match $0 + this.numCap = 2 + } + + // Returns the instruction at the specified pc. + // Precondition: pc > 0 && pc < numInst(). + getInst(pc: number): Inst { + return this.inst[pc] + } + + // Returns the number of instructions in this program. + numInst(): number { + return this.inst.length + } + + // Adds a new instruction to this program, with operator |op| and |pc| equal + // to |numInst()|. + addInst(op: number): void { + this.inst.push(new Inst(op)) + } + + // skipNop() follows any no-op or capturing instructions and returns the + // resulting instruction. + skipNop(pc: number): Inst { + let i = this.inst[pc] + + while (i.op === Inst.NOP || i.op === Inst.CAPTURE) { + i = this.inst[pc] + pc = i.out + } + + return i + } + + // prefix() returns a pair of a literal string that all matches for the + // regexp must start with, and a boolean which is true if the prefix is the + // entire match. The string is returned by appending to |prefix|. + prefix(): [boolean, string] { + let prefix = '' + let i = this.skipNop(this.start) + + if (!Inst.isRuneOp(i.op) || i.runes.length !== 1) { + return [i.op === Inst.MATCH, prefix] + } + + while (Inst.isRuneOp(i.op) && i.runes.length === 1 && (i.arg & RE2Flags.FOLD_CASE) === 0) { + prefix += String.fromCodePoint(i.runes[0]) + i = this.skipNop(i.out) + } + + return [i.op === Inst.MATCH, prefix] + } + + // startCond() returns the leading empty-width conditions that must be true + // in any match. It returns -1 (all bits set) if no matches are possible. + startCond(): number { + let flag = 0 + let pc = this.start + loop: for (;;) { + const i = this.inst[pc] + switch (i.op) { + case Inst.EMPTY_WIDTH: + flag |= i.arg + break + case Inst.FAIL: + return -1 + case Inst.CAPTURE: + case Inst.NOP: + break + default: + break loop + } + pc = i.out + } + return flag + } + + // --- Patch list --- + + // A patchlist is a list of instruction pointers that need to be filled in + // (patched). Because the pointers haven't been filled in yet, we can reuse + // their storage to hold the list. It's kind of sleazy, but works well in + // practice. See http://swtch.com/~rsc/regexp/regexp1.html for inspiration. + + // These aren't really pointers: they're integers, so we can reinterpret them + // this way without using package unsafe. A value l denotes p.inst[l>>1].out + // (l&1==0) or .arg (l&1==1). l == 0 denotes the empty list, okay because we + // start every program with a fail instruction, so we'll never want to point + // at its output link. + + next(l: number): number { + const i = this.inst[l >> 1] + if ((l & 1) === 0) { + return i.out + } + return i.arg + } + + patch(l: PatchList, val: number): void { + let head = l.head + while (head !== 0) { + const i = this.inst[head >> 1] + if ((head & 1) === 0) { + head = i.out + i.out = val + } else { + head = i.arg + i.arg = val + } + } + } + + append(l1: PatchList, l2: PatchList): PatchList { + if (l1.head === 0) return l2 + if (l2.head === 0) return l1 + + // We know exactly where the tail is + const i = this.inst[l1.tail >> 1] + if ((l1.tail & 1) === 0) { + i.out = l2.head + } else { + i.arg = l2.head + } + + return new PatchList(l1.head, l2.tail) + } +} + +export { Prog, PatchList } diff --git a/packages/cel/src/re2/RE2.ts b/packages/cel/src/re2/RE2.ts new file mode 100644 index 0000000..1357bc2 --- /dev/null +++ b/packages/cel/src/re2/RE2.ts @@ -0,0 +1,260 @@ +import { RE2Flags } from './RE2Flags' +import { MachineInput } from './MachineInput' +import { DFA } from './DFA' +import { Inst } from './Inst' +import { PrefilterTree, Prefilter } from './Prefilter' +import { Compiler } from './Compiler' +import { Simplify } from './Simplify' +import { Parser } from './Parser' +import { Utils } from './Utils' + +class RE2 { + expr: string + prog: any + numSubexp: number + cond: any + prefix: string | null + prefixComplete: boolean + prefixRune: number + dfa: any + prefilter: any + namedGroups: any + + // This is visible for testing. + static initTest(expr: string): RE2 { + const re2 = RE2.compile(expr) + const res = new RE2(re2.expr, re2.prog, re2.numSubexp) + res.cond = re2.cond + res.prefix = re2.prefix + res.prefixComplete = re2.prefixComplete + res.prefixRune = re2.prefixRune + res.prefilter = re2.prefilter + return res + } + + static compile(expr: string): RE2 { + return RE2.compileImpl(expr, RE2Flags.PERL) + } + + static compileImpl(expr: string, mode: number): RE2 { + let re = Parser.parse(expr, mode) + const maxCap = re.maxCap() + re = Simplify.simplify(re) + + const prefilter = PrefilterTree.build(re) + + const prog = Compiler.compileRegexp(re) + const re2 = new RE2(expr, prog, maxCap) + + re2.prefilter = prefilter.type === Prefilter.Type.NONE ? null : prefilter + + const [prefixCompl, prefixStr] = prog.prefix() + re2.prefixComplete = prefixCompl + re2.prefix = prefixStr + + if (re2.prefix!.length > 0) { + re2.prefixRune = re2.prefix!.codePointAt(0)! + } + re2.namedGroups = re.namedGroups + return re2 + } + + constructor(expr: string, prog: any, numSubexp = 0) { + this.expr = expr + this.prog = prog + this.numSubexp = numSubexp + this.cond = prog.startCond() + this.prefix = null + this.prefixComplete = false + this.prefixRune = 0 + this.dfa = new DFA(this.prog) + this.prefilter = null + } + + matchPrefixComplete(input: any, pos: number, anchor: number, ncap: number): number[] | null { + let matchStart = -1 + let matchEnd = -1 + const pLen = input.prefixLength(this) + + if (anchor === RE2Flags.UNANCHORED) { + const idx = input.index(this, pos) + if (idx < 0) return null + matchStart = pos + idx + matchEnd = matchStart + pLen + } else if (anchor === RE2Flags.ANCHOR_BOTH) { + // Match must span [pos, endPos] exactly and equal the prefix. + if (input.endPos() - pos !== pLen) return null + const idx = input.index(this, pos) + if (idx !== 0) return null + matchStart = pos + matchEnd = pos + pLen + } else if (anchor === RE2Flags.ANCHOR_START) { + // Match must start at pos and equal the prefix. + const idx = input.index(this, pos) + if (idx !== 0) return null + matchStart = pos + matchEnd = pos + pLen + } + + if (matchStart < 0) return null + + if (ncap > 0) { + const matchcap = new Int32Array(ncap).fill(-1) + matchcap[0] = matchStart + matchcap[1] = matchEnd + return Array.from(matchcap) + } + return [] + } + + executeEngine(input: any, pos: number, anchor: number, ncap: number): number[] | null { + if (this.prefixComplete && (ncap === 0 || this.numSubexp === 0)) { + return this.matchPrefixComplete(input, pos, anchor, ncap) + } + + if (this.prefilter !== null && anchor === RE2Flags.UNANCHORED) { + if (!this.prefilter.eval(input, pos)) { + return null + } + } + + const dfaResult = this.dfa.match(input, pos, anchor) + if (dfaResult !== null) { + return dfaResult ? [] : null + } + + // Minimal NFA fallback for DFA state explosion + return this._nfaFallback(input, pos, anchor) ? [] : null + } + + // Minimal boolean-only NFA for when the DFA bails due to state explosion. + // No captures, no thread pools — just two sets of NFA states swapped each step. + _nfaFallback(input: any, pos: number, anchor: number): boolean { + const prog = this.prog + const endPos = input.endPos() + + const addState = ( + set: Set, + visited: Set, + pc: number, + context: number + ): void => { + if (pc < 0 || pc >= prog.numInst() || visited.has(pc)) return + visited.add(pc) + const inst = prog.getInst(pc) + switch (inst.op) { + case Inst.ALT: + case Inst.ALT_MATCH: + addState(set, visited, inst.out, context) + addState(set, visited, inst.arg, context) + break + case Inst.NOP: + case Inst.CAPTURE: + addState(set, visited, inst.out, context) + break + case Inst.EMPTY_WIDTH: + if ((inst.arg & ~context) === 0) { + addState(set, visited, inst.out, context) + } + break + default: + set.add(pc) + break + } + } + + let current = new Set() + let next = new Set() + // prevRune: the rune immediately before `pos`. See DFA.match for rationale. + let prevRune = -1 + if (pos > 0) { + const r = input.step(pos - 1) >> 3 + if (r >= 0) prevRune = r + } + + for (let i = pos; i <= endPos; i++) { + const rune = i < endPos ? input.step(i) >> 3 : -1 + const width = i < endPos ? input.step(i) & 7 : 0 + const context = Utils.emptyOpContext(prevRune, rune) + + // Add start state at each position for unanchored search + if (anchor === RE2Flags.UNANCHORED || i === pos) { + const visited = new Set() + addState(current, visited, prog.start, context) + } + + // Check for matches before consuming. + // For UNANCHORED/ANCHOR_START, a MATCH at any position succeeds. + // For ANCHOR_BOTH, we must consume the entire input — intermediate + // matches are skipped; only the final post-loop check accepts MATCH. + if (anchor !== RE2Flags.ANCHOR_BOTH) { + for (const pc of current) { + const inst = prog.getInst(pc) + if (inst.op === Inst.MATCH) { + return true + } + } + } + + if (i >= endPos || width === 0) break + + // Step: consume current character + next.clear() + for (const pc of current) { + const inst = prog.getInst(pc) + if (Inst.isRuneOp(inst.op) && inst.matchRune(rune)) { + const nextContext = Utils.emptyOpContext( + rune, + i + width < endPos ? input.step(i + width) >> 3 : -1 + ) + const visited = new Set() + addState(next, visited, inst.out, nextContext) + } + } + + // For unanchored, add start state at next position too + if (anchor === RE2Flags.UNANCHORED) { + const nextRune = i + width < endPos ? input.step(i + width) >> 3 : -1 + const nextContext = Utils.emptyOpContext(rune, nextRune) + const visited = new Set() + addState(next, visited, prog.start, nextContext) + } + + prevRune = rune + ;[current, next] = [next, current] + i += width - 1 // loop increments by 1, but we advanced by width + } + + // Final check for match after processing all input + const endContext = Utils.emptyOpContext(prevRune, -1) + const visited = new Set() + const finalSet = new Set() + for (const pc of current) { + addState(finalSet, visited, pc, endContext) + } + for (const pc of finalSet) { + const inst = prog.getInst(pc) + if (inst.op === Inst.MATCH) return true + } + + return false + } + + numberOfCapturingGroups(): number { + return this.numSubexp + } + + reset(): void { + // No-op: machine pool removed + } + + toString(): string { + return this.expr + } + + match(s: string): boolean { + return this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 0) !== null + } +} + +export { RE2 } diff --git a/packages/cel/src/re2/RE2Flags.ts b/packages/cel/src/re2/RE2Flags.ts new file mode 100644 index 0000000..2dea0c8 --- /dev/null +++ b/packages/cel/src/re2/RE2Flags.ts @@ -0,0 +1,45 @@ +//// Parser flags. +class RE2Flags { + // Fold case during matching (case-insensitive). + static FOLD_CASE = 0x01 + // Treat pattern as a literal string instead of a regexp. + static LITERAL = 0x02 + // Allow character classes like [^a-z] and [[:space:]] to match newline. + static CLASS_NL = 0x04 + // Allow '.' to match newline. + static DOT_NL = 0x08 + // Treat ^ and $ as only matching at beginning and end of text, not + // around embedded newlines. (Perl's default). + static ONE_LINE = 0x10 + // Make repetition operators default to non-greedy. + static NON_GREEDY = 0x20 + // allow Perl extensions: + // non-capturing parens - (?: ) + // non-greedy operators - *? +? ?? {}? + // flag edits - (?i) (?-i) (?i: ) + // i - FoldCase + // m - !OneLine + // s - DotNL + // U - NonGreedy + // line ends: \A \z + // \Q and \E to disable/enable metacharacters + // (?Pexpr) for named captures + // \C (any byte) is not supported. + static PERL_X = 0x40 + // Allow \p{Han}, \P{Han} for Unicode group and negation. + static UNICODE_GROUPS = 0x80 + // Regexp END_TEXT was $, not \z. Internal use only. + static WAS_DOLLAR = 0x100 + + static MATCH_NL = RE2Flags.CLASS_NL | RE2Flags.DOT_NL + // As close to Perl as possible. + static PERL = RE2Flags.CLASS_NL | RE2Flags.ONE_LINE | RE2Flags.PERL_X | RE2Flags.UNICODE_GROUPS + // POSIX syntax. + static POSIX = 0 + //// Anchors + static UNANCHORED = 0 + static ANCHOR_START = 1 + static ANCHOR_BOTH = 2 +} + +export { RE2Flags } diff --git a/packages/cel/src/re2/Regexp.ts b/packages/cel/src/re2/Regexp.ts new file mode 100644 index 0000000..3f9cb89 --- /dev/null +++ b/packages/cel/src/re2/Regexp.ts @@ -0,0 +1,108 @@ +/** + * Regular expression abstract syntax tree. Produced by parser, used by compiler. + */ +export class Regexp { + static Op = { + NO_MATCH: 0, + EMPTY_MATCH: 1, + LITERAL: 2, + CHAR_CLASS: 3, + ANY_CHAR_NOT_NL: 4, + ANY_CHAR: 5, + BEGIN_LINE: 6, + END_LINE: 7, + BEGIN_TEXT: 8, + END_TEXT: 9, + WORD_BOUNDARY: 10, + NO_WORD_BOUNDARY: 11, + CAPTURE: 12, + STAR: 13, + PLUS: 14, + QUEST: 15, + REPEAT: 16, + CONCAT: 17, + ALTERNATE: 18, + LEFT_PAREN: 19, + VERTICAL_BAR: 20 + } as const + + static isPseudoOp(op: number): boolean { + return op >= Regexp.Op.LEFT_PAREN + } + + static emptySubs(): Regexp[] { + return [] + } + + static quoteIfHyphen(rune: number): string { + if (rune === 0x2d) { + return '\\' + } + return '' + } + + static fromRegexp(re: Regexp): Regexp { + const regex = new Regexp(re.op) + regex.flags = re.flags + regex.subs = re.subs + regex.runes = re.runes + regex.cap = re.cap + regex.min = re.min + regex.max = re.max + regex.name = re.name + regex.namedGroups = re.namedGroups + return regex + } + + op: any + flags: number + subs: any[] + runes: number[] + min: number + max: number + cap: number + name: string | null + namedGroups: any + + constructor(op: number) { + this.op = op // operator + this.flags = 0 // bitmap of parse flags + // subexpressions, if any. Never null. + // subs[0] is used as the freelist. + this.subs = Regexp.emptySubs() + this.runes = [] // matched runes, for LITERAL, CHAR_CLASS + this.min = 0 // min for REPEAT + this.max = 0 // max for REPEAT + this.cap = 0 // capturing index, for CAPTURE + this.name = null // capturing name, for CAPTURE + this.namedGroups = Object.create(null) // map of group name -> capturing index + } + + reinit(): void { + this.flags = 0 + this.subs = Regexp.emptySubs() + this.runes = [] + this.cap = 0 + this.min = 0 + this.max = 0 + this.name = null + this.namedGroups = Object.create(null) + } + + // maxCap() walks the regexp to find the maximum capture index. + maxCap(): number { + let m = 0 + if (this.op === Regexp.Op.CAPTURE) { + m = this.cap + } + if (this.subs !== null) { + for (let sub of this.subs) { + const n = sub.maxCap() + if (m < n) { + m = n + } + } + } + return m + } +} diff --git a/packages/cel/src/re2/Simplify.ts b/packages/cel/src/re2/Simplify.ts new file mode 100644 index 0000000..f42057e --- /dev/null +++ b/packages/cel/src/re2/Simplify.ts @@ -0,0 +1,260 @@ +import { RE2Flags } from './RE2Flags' +import { Regexp } from './Regexp' +import { Unicode } from './Unicode' + +class Simplify { + // Simplify returns a regexp equivalent to re but without counted + // repetitions and with various other simplifications, such as + // rewriting /(?:a+)+/ to /a+/. The resulting regexp will execute + // correctly but its string representation will not produce the same + // parse tree, because capturing parentheses may have been duplicated + // or removed. For example, the simplified form for /(x){1,2}/ is + // /(x)(x)?/ but both parentheses capture as $1. The returned regexp + // may share structure with or be the original. + static simplify(re: Regexp): Regexp { + if (re === null) { + return null as any + } + + switch (re.op) { + case Regexp.Op.CAPTURE: { + const sub = Simplify.simplify(re.subs[0]) + if (sub !== re.subs[0]) { + const nre = Regexp.fromRegexp(re) + nre.runes = [] + nre.subs = [sub] + return nre + } + return re + } + + case Regexp.Op.CONCAT: + case Regexp.Op.ALTERNATE: { + const newSubs = [] + let changed = false + + for (let i = 0; i < re.subs.length; i++) { + const sub = re.subs[i] + const nsub = Simplify.simplify(sub) + if (nsub !== sub) { + changed = true + } + + if (re.op === Regexp.Op.CONCAT) { + // If any part of a CONCAT is mathematically impossible, + // the entire CONCAT sequence becomes impossible. + if (nsub.op === Regexp.Op.NO_MATCH) { + return new Regexp(Regexp.Op.NO_MATCH) + } + // Drop empty 0-width match nodes entirely from sequences + if (nsub.op === Regexp.Op.EMPTY_MATCH) { + changed = true + continue + } + // Flatten nested concatenations + if (nsub.op === Regexp.Op.CONCAT) { + changed = true + newSubs.push(...nsub.subs) + continue + } + } else if (re.op === Regexp.Op.ALTERNATE) { + // Drop impossible branches from alternations + if (nsub.op === Regexp.Op.NO_MATCH) { + changed = true + continue + } + // Flatten nested alternations + if (nsub.op === Regexp.Op.ALTERNATE) { + changed = true + newSubs.push(...nsub.subs) + continue + } + } + + newSubs.push(nsub) + } + + if (changed) { + // If we filtered out all nodes, return the mathematically correct fallback + if (newSubs.length === 0) { + return new Regexp( + re.op === Regexp.Op.CONCAT ? Regexp.Op.EMPTY_MATCH : Regexp.Op.NO_MATCH + ) + } + // If only 1 node remains, we don't need a CONCAT/ALT container at all + if (newSubs.length === 1) { + return newSubs[0] + } + + const nre = Regexp.fromRegexp(re) + nre.runes = [] + nre.subs = newSubs + return nre + } + + return re + } + + case Regexp.Op.CHAR_CLASS: { + if (re.runes === null) return re + + // Empty character classes match nothing. + if (re.runes.length === 0) { + return new Regexp(Regexp.Op.NO_MATCH) + } + // Full character classes match everything. + if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) { + return new Regexp(Regexp.Op.ANY_CHAR) + } + // Standard catch-all except newline + if ( + re.runes.length === 4 && + re.runes[0] === 0 && + re.runes[1] === 0x0a - 1 && + re.runes[2] === 0x0a + 1 && + re.runes[3] === Unicode.MAX_RUNE + ) { + return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL) + } + return re + } + + case Regexp.Op.STAR: + case Regexp.Op.PLUS: + case Regexp.Op.QUEST: { + const sub = Simplify.simplify(re.subs[0]) + return Simplify.simplify1(re.op, re.flags, sub, re) + } + + case Regexp.Op.REPEAT: { + // Special special case: x{0} matches the empty string + // and doesn't even need to consider x. + if (re.min === 0 && re.max === 0) { + return new Regexp(Regexp.Op.EMPTY_MATCH) + } + // The fun begins. + const sub = Simplify.simplify(re.subs[0]) + + // x{n,} means at least n matches of x. + if (re.max === -1) { + // Special case: x{0,} is x*. + if (re.min === 0) { + return Simplify.simplify1(Regexp.Op.STAR, re.flags, sub, null) + } + // Special case: x{1,} is x+. + if (re.min === 1) { + return Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null) + } + // General case: x{4,} is xxxx+. + const nre = new Regexp(Regexp.Op.CONCAT) + const subs = [] + for (let i = 0; i < re.min - 1; i++) { + subs.push(sub) + } + subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null)) + nre.subs = subs.slice(0) + + // Ensure newly created CONCAT is properly flattened + return Simplify.simplify(nre) + } + // Special case x{0} handled above. + + // Special case: x{1} is just x. + if (re.min === 1 && re.max === 1) { + return sub + } + + // General case: x{n,m} means n copies of x and m copies of x? + // The machine will do less work if we nest the final m copies, + // so that x{2,5} = xx(x(x(x)?)?)? + + // Build leading prefix: xx. + let prefixSubs = null + if (re.min > 0) { + prefixSubs = [] + for (let i = 0; i < re.min; i++) { + prefixSubs.push(sub) + } + } + + // Build and attach suffix: (x(x(x)?)?)? + if (re.max > re.min) { + let suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, sub, null) + for (let i = re.min + 1; i < re.max; i++) { + const nre2 = new Regexp(Regexp.Op.CONCAT) + nre2.subs = [sub, suffix] + suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, nre2, null) + } + + if (prefixSubs === null) { + return suffix + } + prefixSubs.push(suffix) + } + + if (prefixSubs !== null) { + const prefix = new Regexp(Regexp.Op.CONCAT) + prefix.subs = prefixSubs.slice(0) + // Ensure newly created CONCAT is properly flattened + return Simplify.simplify(prefix) + } + + // Some degenerate case like min > max or min < max < 0. + // Handle as impossible match. + return new Regexp(Regexp.Op.NO_MATCH) + } + } + return re + } + + // simplify1 implements Simplify for the unary OpStar, + // OpPlus, and OpQuest operators. It returns the simple regexp + // equivalent to + // + // Regexp{Op: op, Flags: flags, Sub: {sub}} + // + // under the assumption that sub is already simple, and + // without first allocating that structure. If the regexp + // to be returned turns out to be equivalent to re, simplify1 + // returns re instead. + // + // simplify1 is factored out of Simplify because the implementation + // for other operators generates these unary expressions. + // Letting them call simplify1 makes sure the expressions they + // generate are simple. + static simplify1(op: number, flags: number, sub: Regexp, re: Regexp | null): Regexp { + // Special case: repeat the empty string as much as + // you want, but it's still the empty string. + if (sub.op === Regexp.Op.EMPTY_MATCH) { + return sub + } + + // Handle impossible targets gracefully. + // e.g. Trying to match "NO_MATCH" 0 or 1 times (QUEST/STAR) evaluates to EMPTY_MATCH. + if (sub.op === Regexp.Op.NO_MATCH) { + if (op === Regexp.Op.PLUS) return sub // 1+ times is impossible + return new Regexp(Regexp.Op.EMPTY_MATCH) + } + + // The operators are idempotent if the flags match. + if (op === sub.op && (flags & RE2Flags.NON_GREEDY) === (sub.flags & RE2Flags.NON_GREEDY)) { + return sub + } + + if ( + re !== null && + re.op === op && + (re.flags & RE2Flags.NON_GREEDY) === (flags & RE2Flags.NON_GREEDY) && + sub === re.subs[0] + ) { + return re + } + + const nre = new Regexp(op) + nre.flags = flags + nre.subs = [sub] + return nre + } +} + +export { Simplify } diff --git a/packages/cel/src/re2/Unicode.ts b/packages/cel/src/re2/Unicode.ts new file mode 100644 index 0000000..17d4786 --- /dev/null +++ b/packages/cel/src/re2/Unicode.ts @@ -0,0 +1,163 @@ +import { UnicodeRangeTable } from './UnicodeRangeTable' +import { UnicodeTables } from './UnicodeTables' +/** + * Utilities for dealing with Unicode better than JS does. + */ +class Unicode { + // The highest legal rune value. + static MAX_RUNE = 0x10ffff + // The highest legal ASCII value. + static MAX_ASCII = 0x7f + // The highest legal Latin-1 value. + static MAX_LATIN1 = 0xff + // The highest legal Basic Multilingual Plane (BMP) value. + static MAX_BMP = 0xffff + // Minimum and maximum runes involved in folding. + // Checked during test. + static MIN_FOLD = 0x0041 + static MAX_FOLD = 0x1e943 + + static MIN_HIGH_SURROGATE = 0xd800 + static MAX_HIGH_SURROGATE = 0xdbff + static MIN_LOW_SURROGATE = 0xdc00 + static MAX_LOW_SURROGATE = 0xdfff + static MIN_SUPPLEMENTARY_CODE_POINT = 0x10000 + + // is32 uses binary search to test whether rune is in the specified + // slice of 32-bit ranges. + static is32(ranges: UnicodeRangeTable, r: number): boolean { + // binary search over ranges + let lo = 0 + let hi = ranges.length + while (lo < hi) { + const m = lo + Math.floor((hi - lo) / 2) + + const rlo = ranges.getLo(m) + const rhi = ranges.getHi(m) + if (rlo <= r && r <= rhi) { + const stride = ranges.getStride(m) + return (r - rlo) % stride === 0 + } + if (r < rlo) { + hi = m + } else { + lo = m + 1 + } + } + return false + } + + // is tests whether rune is in the specified table of ranges. + static is(ranges: UnicodeRangeTable, r: number): boolean { + // Fast path for Latin-1 characters using linear search. + if (r <= this.MAX_LATIN1) { + for (let i = 0; i < ranges.length; i++) { + const rhi = ranges.getHi(i) + if (r > rhi) { + continue + } + + const rlo = ranges.getLo(i) + if (r < rlo) { + return false + } + + const stride = ranges.getStride(i) + return (r - rlo) % stride === 0 + } + return false + } + + // Fallback to binary search for runes outside Latin-1 + return ranges.length > 0 && r >= ranges.getLo(0) && this.is32(ranges, r) + } + + // isUpper reports whether the rune is an upper case letter. + static isUpper(r: number): boolean { + if (r <= this.MAX_LATIN1) { + const s = String.fromCodePoint(r) + return s.toUpperCase() === s && s.toLowerCase() !== s + } + return this.is(UnicodeTables.Upper, r) + } + + // simpleFold iterates over Unicode code points equivalent under + // the Unicode-defined simple case folding. Among the code points + // equivalent to rune (including rune itself), SimpleFold returns the + // smallest r >= rune if one exists, or else the smallest r >= 0. + // + // For example: + // SimpleFold('A') = 'a' + // SimpleFold('a') = 'A' + // + // SimpleFold('K') = 'k' + // SimpleFold('k') = '\u212A' (Kelvin symbol, K) + // SimpleFold('\u212A') = 'K' + // + // SimpleFold('1') = '1' + // + // Derived from Go's unicode.SimpleFold. + // + static simpleFold(r: number): number { + // Consult caseOrbit table for special cases (3+ element cycles, lossy + // mappings like ſ→S, and Turkic-specific self-loops). + if (UnicodeTables.CASE_ORBIT!.has(r)) { + return UnicodeTables.CASE_ORBIT!.get(r)! + } + + // Fallback for 2-element orbits: use raw native case conversion. + // The length check rejects multi-char results (e.g., ß→SS) which + // would otherwise be truncated to a non-equivalent codepoint. + const s = String.fromCodePoint(r) + const lower = s.toLowerCase() + if (lower.length === s.length) { + const lowerCp = lower.codePointAt(0)! + if (lowerCp !== r) return lowerCp + } + const upper = s.toUpperCase() + if (upper.length === s.length) { + const upperCp = upper.codePointAt(0)! + if (upperCp !== r) return upperCp + } + return r + } + + // equalsIgnoreCase performs case-insensitive equality comparison + // on the given runes |r1| and |r2|, with special consideration + // for the likely scenario where both runes are ASCII characters. + // If non-ASCII, Unicode case folding will be performed on |r1| + // to compare it to |r2|. + // -1 is interpreted as the end-of-file mark. + static equalsIgnoreCase(r1: number, r2: number): boolean { + // Runes already match, or one of them is EOF + if (r1 < 0 || r2 < 0 || r1 === r2) { + return true + } + + // Fast path for the common case where both runes are ASCII characters. + // Coerces both runes to lowercase if applicable. + if (r1 <= this.MAX_ASCII && r2 <= this.MAX_ASCII) { + if (0x41 <= r1 && r1 <= 0x5a) { + r1 |= 0x20 + } + + if (0x41 <= r2 && r2 <= 0x5a) { + r2 |= 0x20 + } + + return r1 === r2 + } + + // Fall back to full Unicode case folding otherwise. + // Invariant: r1 must be non-negative + for (let r = this.simpleFold(r1); r !== r1; r = this.simpleFold(r)) { + if (r === r2) { + return true + } + } + + return false + } +} + +export { Unicode } diff --git a/packages/cel/src/re2/UnicodeRangeTable.ts b/packages/cel/src/re2/UnicodeRangeTable.ts new file mode 100644 index 0000000..8a9707a --- /dev/null +++ b/packages/cel/src/re2/UnicodeRangeTable.ts @@ -0,0 +1,33 @@ +class UnicodeRangeTable { + data: Uint32Array + isStride1: boolean + SIZE: number + + constructor(data: Uint32Array, isStride1 = false) { + this.data = data // A Uint32Array + this.isStride1 = isStride1 + this.SIZE = isStride1 ? 2 : 3 + } + + // High-performance getters that do NOT allocate memory + getLo(index: number): number { + return this.data[index * this.SIZE] + } + getHi(index: number): number { + return this.data[index * this.SIZE + 1] + } + getStride(index: number): number { + return this.isStride1 ? 1 : this.data[index * this.SIZE + 2] + } + + get(index: number): number[] { + const i = index * this.SIZE + return [this.data[i], this.data[i + 1], this.getStride(index)] + } + + get length(): number { + return this.data.length / this.SIZE + } +} + +export { UnicodeRangeTable } diff --git a/packages/cel/src/re2/UnicodeTables.ts b/packages/cel/src/re2/UnicodeTables.ts new file mode 100644 index 0000000..fed99b3 --- /dev/null +++ b/packages/cel/src/re2/UnicodeTables.ts @@ -0,0 +1,566 @@ +// GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT. +// yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts + +import { UnicodeRangeTable } from './UnicodeRangeTable' + +let _B64_MAP: Uint8Array | null = null +const getB64Map = (): Uint8Array => { + if (!_B64_MAP) { + _B64_MAP = new Uint8Array(256) + const b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-' + for (let i = 0; i < 64; i++) { + _B64_MAP[b.charCodeAt(i)] = i + } + } + return _B64_MAP +} + +const decodeVLQ = (str: string): number[] => { + const b64 = getB64Map() + const res: number[] = [] + let value = 0, + shift = 0 + for (let i = 0; i < str.length; i++) { + const digit = b64[str.charCodeAt(i)] + value |= (digit & 0x1f) << shift + if ((digit & 0x20) === 0) { + res.push(value) + value = 0 + shift = 0 + } else { + shift += 5 + } + } + return res +} + +const decodeRanges = (str: string, isStride1: boolean): Uint32Array => { + if (str.length === 0) return new Uint32Array(0) + const res = decodeVLQ(str) + const numRanges = isStride1 ? res.length / 2 : res.length / 3 + const out = new Uint32Array(numRanges * 3) + let current = 0, + resIdx = 0 + for (let i = 0; i < numRanges; i++) { + current += res[resIdx++] + out[i * 3] = current + current += res[resIdx++] + out[i * 3 + 1] = current + out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++] + } + return out +} + +const decodeOrbit = (str: string): Map => { + const res = decodeVLQ(str) + const map = new Map() + let currentKey = 0 + for (let i = 0; i < res.length; i += 2) { + currentKey += res[i] + map.set(currentKey, res[i + 1]) + } + return map +} + +// Merges two stride-encoded UnicodeRangeTables. Expands any stride>1 +// ranges to individual codepoints, then coalesces contiguous runs. +const mergeRanges = (a: Uint32Array, b: Uint32Array): Uint32Array => { + if (b.length === 0) return a + if (a.length === 0) return b + const points: [number, number][] = [] + const push = (arr: Uint32Array): void => { + for (let i = 0; i < arr.length; i += 3) { + const lo = arr[i], + hi = arr[i + 1], + stride = arr[i + 2] + if (stride === 1) { + points.push([lo, hi]) + } else { + for (let cp = lo; cp <= hi; cp += stride) points.push([cp, cp]) + } + } + } + push(a) + push(b) + points.sort((x, y) => x[0] - y[0]) + const merged: [number, number][] = [] + for (const [lo, hi] of points) { + const last = merged[merged.length - 1] + if (last && last[1] + 1 >= lo) { + if (hi > last[1]) last[1] = hi + } else { + merged.push([lo, hi]) + } + } + const out = new Uint32Array(merged.length * 3) + for (let i = 0; i < merged.length; i++) { + out[i * 3] = merged[i][0] + out[i * 3 + 1] = merged[i][1] + out[i * 3 + 2] = 1 + } + return out +} + +// Sweeps the codepoint space using a platform property-escape regex and +// returns stride-1 ranges. Surrogates are included — String.fromCodePoint +// returns the lone surrogate char and platform regex matches \p{Cs} on it. +const sweepPlatform = (pattern: string): Uint32Array => { + const re = new RegExp(pattern, 'u') + const ranges: number[] = [] + let start = -1 + for (let cp = 0; cp <= 0x10ffff; cp++) { + if (re.test(String.fromCodePoint(cp))) { + if (start < 0) start = cp + } else if (start >= 0) { + ranges.push(start, cp - 1, 1) + start = -1 + } + } + if (start >= 0) ranges.push(start, 0x10ffff, 1) + return Uint32Array.from(ranges) +} + +class LazyDecoder { + private readonly initializer: Record V> + private readonly cache: Map + constructor(initializer: Record V>) { + this.initializer = initializer + this.cache = new Map() + } + has(key: string): boolean { + return key in this.initializer + } + get(key: string): V | null { + if (this.cache.has(key)) return this.cache.get(key)! + const fn = this.initializer[key] + const val = fn ? fn() : null + this.cache.set(key, val) + return val + } +} + +class UnicodeTables { + private static _CASE_ORBIT: Map | null = null + static get CASE_ORBIT(): Map { + if (!this._CASE_ORBIT) { + this._CASE_ORBIT = decodeOrbit( + 'rDqpII-LsD+0HGrpIsCxJzElODoODrOnByP-Mz+HTieNj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeE1eDmpII0fjB4c+BgkHChkHKikHDjkHBkkHImkHZnkHhhGlkH9O70H-Io8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HJ48HB58HB68HB78HB88HB98HB+8HB-8HJo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HM89HLlaFs+HQwcQwdQ8-HzJpdErCBlGgphBokHjMu+pBBv+pBDy+pBBz+pBB0+pBB1+pBw5Um4+BBl4+B68cg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417CD717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27C' + ) + } + return this._CASE_ORBIT + } + + // Additions from Unicode 15.0 → 16.0 per stable general-category name. + // Merged unconditionally with platform sweep output; no-op on 16.0+ engines. + private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({ + L: () => + decodeRanges( + 'pkHBBh6iBCBNCBkvXzBB36BbBKWB9JCB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBjhDsBBz8HxmWxmWBcBDgwhCgwhCBsTB', + false + ), + LC: () => decodeRanges('pkHBh6iBCNC0rZVLV', true), + Ll: () => decodeRanges('qkHj6iBj6iBO1sZ1sZBUB', false), + Lm: () => decodeRanges('uqjChBhBx+XCBpBBB', false), + Lo: () => + decodeRanges( + 'guhCzBB36BDBCzLzLBBB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBmhDnBB18HxmWxmWBcBDgwhCgwhCBsTB', + false + ), + Lu: () => decodeRanges('pkHi6iBi6iBBOOC0rZ0rZBUB', false), + M: () => decodeRanges('3kCymhCymhCBDBvM8lB8lBBHBCDDCDBCEBCPPB47C47CkuQRB-lhBBB', false), + Mc: () => decodeRanges('49kCCBIDDCDBCBBCvavaswSCB', false), + Mn: () => decodeRanges('3kCymhCymhCBDBvM-lB-lBBEBOECPBB47CkuQkuQBKBECB-lhBBB', false), + N: () => decodeRanges('gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ', true), + Nd: () => decodeRanges('gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ', true), + P: () => decodeRanges('u6GBBwBvv8Bvv8BmzBBBCBBpgCssUssUBBBwkeAB', false), + Pd: () => decodeRanges('urjCA', true), + Po: () => decodeRanges('u6GBBwB1i+B1i+BBCCBpgCpgCssUCBwkeAB', false), + S: () => + decodeRanges('nhJCBz+CDBlPBBK-82B-82BBxzvBxzvBBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB', false), + Sm: () => decodeRanges('usjCB', true), + So: () => decodeRanges('nhJCBz+CDBlPBBKxwmDxwmDBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB', false) + }) + + // Additions from Unicode 15.0 → 16.0 per stable script name. + private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ + Arabic: () => decodeRanges('3kCrxhCrxhCBBB4BAB', false), + Balinese: () => decodeRanges('u6GBwBA', true), + Common: () => + decodeRanges('nhJCBz+CDBlPBBKxwmDxwmDB4HBHzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB', false), + Cyrillic: () => decodeRanges('pkHB', true), + Egyptian_Hieroglyphs: () => decodeRanges('gjtC68D', true), + Han: () => decodeRanges('w-6FtT', true), + Kawi: () => decodeRanges('66nCA', true), + Khitan_Small_Script: () => decodeRanges('-njDA', true), + Latin: () => decodeRanges('r+pBCNC', true), + Myanmar: () => decodeRanges('w2lCT', true) + }) + + // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw + // SyntaxError on these names, so platform sweep is impossible. + private static _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ + Garay: () => new UnicodeRangeTable(decodeRanges('gqjClBEcJB', true)), + Gurung_Khema: () => new UnicodeRangeTable(decodeRanges('go4C5B', true)), + Kirat_Rai: () => new UnicodeRangeTable(decodeRanges('gq7C5B', true)), + Ol_Onal: () => new UnicodeRangeTable(decodeRanges('wu5DqBFA', true)), + Sunuwar: () => new UnicodeRangeTable(decodeRanges('g+mChBPJ', true)), + Todhri: () => new UnicodeRangeTable(decodeRanges('guhCzB', true)), + Tulu_Tigalari: () => + new UnicodeRangeTable(decodeRanges('g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB', false)) + }) + + static readonly STABLE_CATEGORY_NAMES: ReadonlySet = new Set([ + 'C', + 'Cc', + 'Cf', + 'Cn', + 'Co', + 'Cs', + 'L', + 'LC', + 'Ll', + 'Lm', + 'Lo', + 'Lt', + 'Lu', + 'M', + 'Mc', + 'Me', + 'Mn', + 'N', + 'Nd', + 'Nl', + 'No', + 'P', + 'Pc', + 'Pd', + 'Pe', + 'Pf', + 'Pi', + 'Po', + 'Ps', + 'S', + 'Sc', + 'Sk', + 'Sm', + 'So', + 'Z', + 'Zl', + 'Zp', + 'Zs' + ]) + static readonly STABLE_SCRIPT_NAMES: ReadonlySet = new Set([ + 'Adlam', + 'Ahom', + 'Anatolian_Hieroglyphs', + 'Arabic', + 'Armenian', + 'Avestan', + 'Balinese', + 'Bamum', + 'Bassa_Vah', + 'Batak', + 'Bengali', + 'Bhaiksuki', + 'Bopomofo', + 'Brahmi', + 'Braille', + 'Buginese', + 'Buhid', + 'Canadian_Aboriginal', + 'Carian', + 'Caucasian_Albanian', + 'Chakma', + 'Cham', + 'Cherokee', + 'Chorasmian', + 'Common', + 'Coptic', + 'Cuneiform', + 'Cypriot', + 'Cypro_Minoan', + 'Cyrillic', + 'Deseret', + 'Devanagari', + 'Dives_Akuru', + 'Dogra', + 'Duployan', + 'Egyptian_Hieroglyphs', + 'Elbasan', + 'Elymaic', + 'Ethiopic', + 'Georgian', + 'Glagolitic', + 'Gothic', + 'Grantha', + 'Greek', + 'Gujarati', + 'Gunjala_Gondi', + 'Gurmukhi', + 'Han', + 'Hangul', + 'Hanifi_Rohingya', + 'Hanunoo', + 'Hatran', + 'Hebrew', + 'Hiragana', + 'Imperial_Aramaic', + 'Inherited', + 'Inscriptional_Pahlavi', + 'Inscriptional_Parthian', + 'Javanese', + 'Kaithi', + 'Kannada', + 'Katakana', + 'Kawi', + 'Kayah_Li', + 'Kharoshthi', + 'Khitan_Small_Script', + 'Khmer', + 'Khojki', + 'Khudawadi', + 'Lao', + 'Latin', + 'Lepcha', + 'Limbu', + 'Linear_A', + 'Linear_B', + 'Lisu', + 'Lycian', + 'Lydian', + 'Mahajani', + 'Makasar', + 'Malayalam', + 'Mandaic', + 'Manichaean', + 'Marchen', + 'Masaram_Gondi', + 'Medefaidrin', + 'Meetei_Mayek', + 'Mende_Kikakui', + 'Meroitic_Cursive', + 'Meroitic_Hieroglyphs', + 'Miao', + 'Modi', + 'Mongolian', + 'Mro', + 'Multani', + 'Myanmar', + 'Nabataean', + 'Nag_Mundari', + 'Nandinagari', + 'New_Tai_Lue', + 'Newa', + 'Nko', + 'Nushu', + 'Nyiakeng_Puachue_Hmong', + 'Ogham', + 'Ol_Chiki', + 'Old_Hungarian', + 'Old_Italic', + 'Old_North_Arabian', + 'Old_Permic', + 'Old_Persian', + 'Old_Sogdian', + 'Old_South_Arabian', + 'Old_Turkic', + 'Old_Uyghur', + 'Oriya', + 'Osage', + 'Osmanya', + 'Pahawh_Hmong', + 'Palmyrene', + 'Pau_Cin_Hau', + 'Phags_Pa', + 'Phoenician', + 'Psalter_Pahlavi', + 'Rejang', + 'Runic', + 'Samaritan', + 'Saurashtra', + 'Sharada', + 'Shavian', + 'Siddham', + 'SignWriting', + 'Sinhala', + 'Sogdian', + 'Sora_Sompeng', + 'Soyombo', + 'Sundanese', + 'Syloti_Nagri', + 'Syriac', + 'Tagalog', + 'Tagbanwa', + 'Tai_Le', + 'Tai_Tham', + 'Tai_Viet', + 'Takri', + 'Tamil', + 'Tangsa', + 'Tangut', + 'Telugu', + 'Thaana', + 'Thai', + 'Tibetan', + 'Tifinagh', + 'Tirhuta', + 'Toto', + 'Ugaritic', + 'Unknown', + 'Vai', + 'Vithkuqi', + 'Wancho', + 'Warang_Citi', + 'Yezidi', + 'Yi', + 'Zanabazar_Square' + ]) + static readonly NEW_SCRIPT_NAMES: ReadonlySet = new Set([ + 'Garay', + 'Gurung_Khema', + 'Kirat_Rai', + 'Ol_Onal', + 'Sunuwar', + 'Todhri', + 'Tulu_Tigalari' + ]) + + private static _sweepCache = new Map() + private static _foldCache = new Map() + + // Returns the base range table for a property name, or null if unknown. + // Stable names: platform sweep + bundled delta (15.0 → 16.0). + // New-in-16.0 script names: bundled full table. + static buildForProperty(name: string): UnicodeRangeTable | null { + if (this.NEW_SCRIPT_NAMES.has(name)) { + return this._NEW_SCRIPTS.get(name) + } + let kind: 'category' | 'script' | null = null + let pattern: string | null = null + if (this.STABLE_CATEGORY_NAMES.has(name)) { + kind = 'category' + pattern = `\\p{General_Category=${name}}` + } else if (this.STABLE_SCRIPT_NAMES.has(name)) { + kind = 'script' + pattern = `\\p{Script=${name}}` + } else return null + + const cacheKey = `${kind}:${name}` + const cached = this._sweepCache.get(cacheKey) + if (cached) return cached + + const base = sweepPlatform(pattern) + const delta = + kind === 'category' ? this._DELTA_CATEGORIES.get(name) : this._DELTA_SCRIPTS.get(name) + const merged = delta ? mergeRanges(base, delta) : base + const table = new UnicodeRangeTable(merged) + this._sweepCache.set(cacheKey, table) + return table + } + + // Computes the fold-overlay for a property name: additional runes that + // fold to some rune already in the base class. Returns null if no overlay + // is needed (base class is fold-stable). + static buildFoldOverlay(name: string): UnicodeRangeTable | null { + const cached = this._foldCache.get(name) + if (cached !== undefined) return cached + const base = this.buildForProperty(name) + if (!base) { + this._foldCache.set(name, null) + return null + } + const inBase = (r: number): boolean => { + let lo = 0, + hi = base.length + while (lo < hi) { + const m = (lo + hi) >> 1 + const rlo = base.getLo(m), + rhi = base.getHi(m) + if (r < rlo) hi = m + else if (r > rhi) lo = m + 1 + else return (r - rlo) % base.getStride(m) === 0 + } + return false + } + // Inline simpleFold to avoid circular import with Unicode.ts. + const orbit = UnicodeTables.CASE_ORBIT + const simpleFold = (r: number): number => { + if (orbit.has(r)) return orbit.get(r)! + const s = String.fromCodePoint(r) + const lower = s.toLowerCase() + if (lower.length === s.length) { + const lowerCp = lower.codePointAt(0)! + if (lowerCp !== r) return lowerCp + } + const upper = s.toUpperCase() + if (upper.length === s.length) { + const upperCp = upper.codePointAt(0)! + if (upperCp !== r) return upperCp + } + return r + } + const extras = new Set() + for (let i = 0; i < base.length; i++) { + const lo = base.getLo(i), + hi = base.getHi(i), + stride = base.getStride(i) + for (let cp = lo; cp <= hi; cp += stride) { + let r = simpleFold(cp) + while (r !== cp) { + if (!inBase(r)) extras.add(r) + r = simpleFold(r) + } + } + } + if (extras.size === 0) { + this._foldCache.set(name, null) + return null + } + const sorted = Array.from(extras).sort((a, b) => a - b) + const merged: [number, number][] = [] + for (const cp of sorted) { + const last = merged[merged.length - 1] + if (last && last[1] + 1 === cp) last[1] = cp + else merged.push([cp, cp]) + } + const out = new Uint32Array(merged.length * 3) + for (let i = 0; i < merged.length; i++) { + out[i * 3] = merged[i][0] + out[i * 3 + 1] = merged[i][1] + out[i * 3 + 2] = 1 + } + const table = new UnicodeRangeTable(out) + this._foldCache.set(name, table) + return table + } + + // --- Legacy API surface used by Parser --- + + static CATEGORIES = { + has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name) + } + + static SCRIPTS = { + has: (name: string): boolean => + UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name) + } + + static FOLD_CATEGORIES = { + has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name) + } + + static FOLD_SCRIPT = { + has: (name: string): boolean => + UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name) + } + + static get Upper(): UnicodeRangeTable { + return UnicodeTables.buildForProperty('Lu')! + } +} + +export { UnicodeTables } diff --git a/packages/cel/src/re2/Utils.ts b/packages/cel/src/re2/Utils.ts new file mode 100644 index 0000000..ee25a30 --- /dev/null +++ b/packages/cel/src/re2/Utils.ts @@ -0,0 +1,112 @@ +import { Unicode } from './Unicode' +/** + * Various constants and helper utilities. + */ +class Utils { + static METACHARACTERS = '\\.+*?()|[]{}^$' + + //// EMPTY_* flags + static EMPTY_BEGIN_LINE = 0x01 + static EMPTY_END_LINE = 0x02 + static EMPTY_BEGIN_TEXT = 0x04 + static EMPTY_END_TEXT = 0x08 + static EMPTY_WORD_BOUNDARY = 0x10 + static EMPTY_NO_WORD_BOUNDARY = 0x20 + static EMPTY_ALL = -1 + + static emptyInts(): number[] { + return [] + } + + // Returns true iff |c| is an ASCII letter or decimal digit. + static isalnum(c: number): boolean { + return (0x30 <= c && c <= 0x39) || (0x61 <= c && c <= 0x7a) || (0x41 <= c && c <= 0x5a) + } + + // If |c| is an ASCII hex digit, returns its value, otherwise -1. + static unhex(c: number): number { + if (0x30 <= c && c <= 0x39) { + return c - 0x30 + } + if (0x61 <= c && c <= 0x66) { + return c - 0x61 + 10 + } + if (0x41 <= c && c <= 0x46) { + return c - 0x41 + 10 + } + return -1 + } + + // Returns the array of runes in the specified UTF-16 string. + static stringToRunes(str: string): number[] { + return Array.from(String(str)).map((s) => s.codePointAt(0)!) + } + + // Returns the Java UTF-16 string containing the single rune |r|. + static runeToString(r: number): string { + return String.fromCodePoint(r) + } + + // isWordRune reports whether r is consider a ``word character'' + // during the evaluation of the \b and \B zero-width assertions. + // These assertions are ASCII-only: the word characters are [A-Za-z0-9_]. + static isWordRune(r: number): boolean { + return ( + (0x61 <= r && r <= 0x7a) || (0x41 <= r && r <= 0x5a) || (0x30 <= r && r <= 0x39) || r === 0x5f + ) + } + + // emptyOpContext returns the zero-width assertions satisfied at the position + // between the runes r1 and r2, a bitmask of EMPTY_* flags. + // Passing r1 == -1 indicates that the position is at the beginning of the + // text. + // Passing r2 == -1 indicates that the position is at the end of the text. + // eslint-disable-next-line no-warning-comments + // TODO(adonovan): move to Machine. + static emptyOpContext(r1: number, r2: number): number { + let op = 0 + if (r1 < 0) { + op |= this.EMPTY_BEGIN_TEXT | this.EMPTY_BEGIN_LINE + } + if (r1 === 0x0a) { + op |= this.EMPTY_BEGIN_LINE + } + if (r2 < 0) { + op |= this.EMPTY_END_TEXT | this.EMPTY_END_LINE + } + if (r2 === 0x0a) { + op |= this.EMPTY_END_LINE + } + if (this.isWordRune(r1) !== this.isWordRune(r2)) { + op |= this.EMPTY_WORD_BOUNDARY + } else { + op |= this.EMPTY_NO_WORD_BOUNDARY + } + return op + } + + /** + * Returns a string that quotes all regular expression metacharacters inside the argument text; + * the returned string is a regular expression matching the literal text. For example, + * {@code quoteMeta("[foo]").equals("\\[foo\\]")}. + * @param {string} s + * @returns {string} + */ + static quoteMeta(str: string): string { + return str + .split('') // A char loop is correct because all metacharacters fit in one UTF-16 code. + .map((s) => { + if (this.METACHARACTERS.indexOf(s) >= 0) { + return `\\${s}` + } + return s + }) + .join('') + } + + static charCount(codePoint: number): number { + return codePoint > Unicode.MAX_BMP ? 2 : 1 + } +} + +export { Utils } diff --git a/packages/cel/src/re2/__fixtures__/basic.dat b/packages/cel/src/re2/__fixtures__/basic.dat new file mode 100644 index 0000000..1776b1f --- /dev/null +++ b/packages/cel/src/re2/__fixtures__/basic.dat @@ -0,0 +1,217 @@ +NOTE all standard compliant implementations should pass these : 2002-05-31 + +BE abracadabra$ abracadabracadabra (7,18) +BE a...b abababbb (2,7) +BE XXXXXX ..XXXXXX (2,8) +E \) () (1,2) +BE a] a]a (0,2) +B } } (0,1) +E \} } (0,1) +BE \] ] (0,1) +B ] ] (0,1) +E ] ] (0,1) +B { { (0,1) +B } } (0,1) +BE ^a ax (0,1) +BE \^a a^a (1,3) +BE a\^ a^ (0,2) +BE a$ aa (1,2) +BE a\$ a$ (0,2) +BE ^$ NULL (0,0) +E $^ NULL (0,0) +E a($) aa (1,2)(2,2) +E a*(^a) aa (0,1)(0,1) +E (..)*(...)* a (0,0) +E (..)*(...)* abcd (0,4)(2,4) +E (ab|a)(bc|c) abc (0,3)(0,2)(2,3) +E (ab)c|abc abc (0,3)(0,2) +E a{0}b ab (1,2) +E (a*)(b?)(b+)b{3} aaabbbbbbb (0,10)(0,3)(3,4)(4,7) +E (a*)(b{0,1})(b{1,})b{3} aaabbbbbbb (0,10)(0,3)(3,4)(4,7) +E a{9876543210} NULL BADBR +E ((a|a)|a) a (0,1)(0,1)(0,1) +E (a*)(a|aa) aaaa (0,4)(0,3)(3,4) +E a*(a.|aa) aaaa (0,4)(2,4) +E a(b)|c(d)|a(e)f aef (0,3)(?,?)(?,?)(1,2) +E (a|b)?.* b (0,1)(0,1) +E (a|b)c|a(b|c) ac (0,2)(0,1) +E (a|b)c|a(b|c) ab (0,2)(?,?)(1,2) +E (a|b)*c|(a|ab)*c abc (0,3)(1,2) +E (a|b)*c|(a|ab)*c xc (1,2) +E (.a|.b).*|.*(.a|.b) xa (0,2)(0,2) +E a?(ab|ba)ab abab (0,4)(0,2) +E a?(ac{0}b|ba)ab abab (0,4)(0,2) +E ab|abab abbabab (0,2) +E aba|bab|bba baaabbbaba (5,8) +E aba|bab baaabbbaba (6,9) +E (aa|aaa)*|(a|aaaaa) aa (0,2)(0,2) +E (a.|.a.)*|(a|.a...) aa (0,2)(0,2) +E ab|a xabc (1,3) +E ab|a xxabc (2,4) +Ei (Ab|cD)* aBcD (0,4)(2,4) +BE [^-] --a (2,3) +BE [a-]* --a (0,3) +BE [a-m-]* --amoma-- (0,4) +E :::1:::0:|:::1:1:0: :::0:::1:::1:::0: (8,17) +E :::1:::0:|:::1:1:1: :::0:::1:::1:::0: (8,17) +{E [[:upper:]] A (0,1) [[]] not supported +E [[:lower:]]+ `az{ (1,3) +E [[:upper:]]+ @AZ[ (1,3) +# No collation in Go +#BE [[-]] [[-]] (2,4) +#BE [[.NIL.]] NULL ECOLLATE +#BE [[=aleph=]] NULL ECOLLATE +} +BE$ \n \n (0,1) +BEn$ \n \n (0,1) +BE$ [^a] \n (0,1) +BE$ \na \na (0,2) +E (a)(b)(c) abc (0,3)(0,1)(1,2)(2,3) +BE xxx xxx (0,3) +E1 (^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$) feb 6, (0,6) +E1 (^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$) 2/7 (0,3) +E1 (^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$) feb 1,Feb 6 (5,11) +E3 ((((((((((((((((((((((((((((((x)))))))))))))))))))))))))))))) x (0,1)(0,1)(0,1) +E3 ((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))* xx (0,2)(1,2)(1,2) +E a?(ab|ba)* ababababababababababababababababababababababababababababababababababababababababa (0,81)(79,81) +E abaa|abbaa|abbbaa|abbbbaa ababbabbbabbbabbbbabbbbaa (18,25) +E abaa|abbaa|abbbaa|abbbbaa ababbabbbabbbabbbbabaa (18,22) +E aaac|aabc|abac|abbc|baac|babc|bbac|bbbc baaabbbabac (7,11) +BE$ .* \x01\xff (0,2) +E aaaa|bbbb|cccc|ddddd|eeeeee|fffffff|gggg|hhhh|iiiii|jjjjj|kkkkk|llll XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa (53,57) +L aaaa\nbbbb\ncccc\nddddd\neeeeee\nfffffff\ngggg\nhhhh\niiiii\njjjjj\nkkkkk\nllll XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa NOMATCH +E a*a*a*a*a*b aaaaaaaaab (0,10) +BE ^ NULL (0,0) +BE $ NULL (0,0) +BE ^$ NULL (0,0) +BE ^a$ a (0,1) +BE abc abc (0,3) +BE abc xabcy (1,4) +BE abc ababc (2,5) +BE ab*c abc (0,3) +BE ab*bc abc (0,3) +BE ab*bc abbc (0,4) +BE ab*bc abbbbc (0,6) +E ab+bc abbc (0,4) +E ab+bc abbbbc (0,6) +E ab?bc abbc (0,4) +E ab?bc abc (0,3) +E ab?c abc (0,3) +BE ^abc$ abc (0,3) +BE ^abc abcc (0,3) +BE abc$ aabc (1,4) +BE ^ abc (0,0) +BE $ abc (3,3) +BE a.c abc (0,3) +BE a.c axc (0,3) +BE a.*c axyzc (0,5) +BE a[bc]d abd (0,3) +BE a[b-d]e ace (0,3) +BE a[b-d] aac (1,3) +BE a[-b] a- (0,2) +BE a[b-] a- (0,2) +BE a] a] (0,2) +BE a[]]b a]b (0,3) +BE a[^bc]d aed (0,3) +BE a[^-b]c adc (0,3) +BE a[^]b]c adc (0,3) +E ab|cd abc (0,2) +E ab|cd abcd (0,2) +E a\(b a(b (0,3) +E a\(*b ab (0,2) +E a\(*b a((b (0,4) +E ((a)) abc (0,1)(0,1)(0,1) +E (a)b(c) abc (0,3)(0,1)(2,3) +E a+b+c aabbabc (4,7) +E a* aaa (0,3) +E (a*)* - (0,0)(0,0) +E (a*)+ - (0,0)(0,0) +E (a*|b)* - (0,0)(0,0) +E (a+|b)* ab (0,2)(1,2) +E (a+|b)+ ab (0,2)(1,2) +E (a+|b)? ab (0,1)(0,1) +BE [^ab]* cde (0,3) +E (^)* - (0,0)(0,0) +BE a* NULL (0,0) +E ([abc])*d abbbcd (0,6)(4,5) +E ([abc])*bcd abcd (0,4)(0,1) +E a|b|c|d|e e (0,1) +E (a|b|c|d|e)f ef (0,2)(0,1) +E ((a*|b))* - (0,0)(0,0)(0,0) +BE abcd*efg abcdefg (0,7) +BE ab* xabyabbbz (1,3) +BE ab* xayabbbz (1,2) +E (ab|cd)e abcde (2,5)(2,4) +BE [abhgefdc]ij hij (0,3) +E (a|b)c*d abcd (1,4)(1,2) +E (ab|ab*)bc abc (0,3)(0,1) +E a([bc]*)c* abc (0,3)(1,3) +E a([bc]*)(c*d) abcd (0,4)(1,3)(3,4) +E a([bc]+)(c*d) abcd (0,4)(1,3)(3,4) +E a([bc]*)(c+d) abcd (0,4)(1,2)(2,4) +E a[bcd]*dcdcde adcdcde (0,7) +E (ab|a)b*c abc (0,3)(0,2) +E ((a)(b)c)(d) abcd (0,4)(0,3)(0,1)(1,2)(3,4) +BE [A-Za-z_][A-Za-z0-9_]* alpha (0,5) +E ^a(bc+|b[eh])g|.h$ abh (1,3) +E (bc+d$|ef*g.|h?i(j|k)) effgz (0,5)(0,5) +E (bc+d$|ef*g.|h?i(j|k)) ij (0,2)(0,2)(1,2) +E (bc+d$|ef*g.|h?i(j|k)) reffgz (1,6)(1,6) +E (((((((((a))))))))) a (0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1) +BE multiple words multiple words yeah (0,14) +E (.*)c(.*) abcde (0,5)(0,2)(3,5) +BE abcd abcd (0,4) +E a(bc)d abcd (0,4)(1,3) +E a[-]?c ac (0,3) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Qaddafi (0,15)(?,?)(10,12) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Mo'ammar Gadhafi (0,16)(?,?)(11,13) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Kaddafi (0,15)(?,?)(10,12) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Qadhafi (0,15)(?,?)(10,12) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Gadafi (0,14)(?,?)(10,11) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Mu'ammar Qadafi (0,15)(?,?)(11,12) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Moamar Gaddafi (0,14)(?,?)(9,11) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Mu'ammar Qadhdhafi (0,18)(?,?)(13,15) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Khaddafi (0,16)(?,?)(11,13) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Ghaddafy (0,16)(?,?)(11,13) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Ghadafi (0,15)(?,?)(11,12) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Ghaddafi (0,16)(?,?)(11,13) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muamar Kaddafi (0,14)(?,?)(9,11) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Quathafi (0,16)(?,?)(11,13) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Gheddafi (0,16)(?,?)(11,13) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Moammar Khadafy (0,15)(?,?)(11,12) +E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Moammar Qudhafi (0,15)(?,?)(10,12) +E a+(b|c)*d+ aabcdd (0,6)(3,4) +E ^.+$ vivi (0,4) +E ^(.+)$ vivi (0,4)(0,4) +E ^([^!.]+).att.com!(.+)$ gryphon.att.com!eby (0,19)(0,7)(16,19) +E ^([^!]+!)?([^!]+)$ bas (0,3)(?,?)(0,3) +E ^([^!]+!)?([^!]+)$ bar!bas (0,7)(0,4)(4,7) +E ^([^!]+!)?([^!]+)$ foo!bas (0,7)(0,4)(4,7) +E ^.+!([^!]+!)([^!]+)$ foo!bar!bas (0,11)(4,8)(8,11) +E ((foo)|(bar))!bas bar!bas (0,7)(0,3)(?,?)(0,3) +E ((foo)|(bar))!bas foo!bar!bas (4,11)(4,7)(?,?)(4,7) +E ((foo)|(bar))!bas foo!bas (0,7)(0,3)(0,3) +E ((foo)|bar)!bas bar!bas (0,7)(0,3) +E ((foo)|bar)!bas foo!bar!bas (4,11)(4,7) +E ((foo)|bar)!bas foo!bas (0,7)(0,3)(0,3) +E (foo|(bar))!bas bar!bas (0,7)(0,3)(0,3) +E (foo|(bar))!bas foo!bar!bas (4,11)(4,7)(4,7) +E (foo|(bar))!bas foo!bas (0,7)(0,3) +E (foo|bar)!bas bar!bas (0,7)(0,3) +E (foo|bar)!bas foo!bar!bas (4,11)(4,7) +E (foo|bar)!bas foo!bas (0,7)(0,3) +E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ foo!bar!bas (0,11)(0,11)(?,?)(?,?)(4,8)(8,11) +E ^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$ bas (0,3)(?,?)(0,3) +E ^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$ bar!bas (0,7)(0,4)(4,7) +E ^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$ foo!bar!bas (0,11)(?,?)(?,?)(4,8)(8,11) +E ^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$ foo!bas (0,7)(0,4)(4,7) +E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ bas (0,3)(0,3)(?,?)(0,3) +E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ bar!bas (0,7)(0,7)(0,4)(4,7) +E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ foo!bar!bas (0,11)(0,11)(?,?)(?,?)(4,8)(8,11) +E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ foo!bas (0,7)(0,7)(0,4)(4,7) +E .*(/XXX).* /XXX (0,4)(0,4) +E .*(\\XXX).* \XXX (0,4)(0,4) +E \\XXX \XXX (0,4) +E .*(/000).* /000 (0,4)(0,4) +E .*(\\000).* \000 (0,4)(0,4) +E \\000 \000 (0,4) diff --git a/packages/cel/src/re2/__fixtures__/find.ts b/packages/cel/src/re2/__fixtures__/find.ts new file mode 100644 index 0000000..65f1410 --- /dev/null +++ b/packages/cel/src/re2/__fixtures__/find.ts @@ -0,0 +1,211 @@ +class Test { + pat: string + text: string + matches: number[][] + + constructor(pat: string, text: string, n: number, ...x: number[]) { + this.pat = pat + this.text = text + this.matches = [] + + if (n > 0) { + const runLength = Math.floor(x.length / n) + for (let i = 0, j = 0; i < n; i++) { + this.matches[i] = x.slice(j, j + runLength) + j += runLength + if (j > x.length) { + throw new Error('invalid build entry') + } + } + } + } + + toString(): string { + return `pat=${this.pat} text=${this.text} len=${this.matches.length} matches=${JSON.stringify( + this.matches + )}` + } +} + +export const FIND_TESTS = [ + new Test('', '', 1, 0, 0), + new Test('^abcdefg', 'abcdefg', 1, 0, 7), + new Test('a+', 'baaab', 1, 1, 4), + new Test('abcd..', 'abcdef', 1, 0, 6), + new Test('a', 'a', 1, 0, 1), + new Test('x', 'y', 0), + new Test('b', 'abc', 1, 1, 2), + new Test('.', 'a', 1, 0, 1), + new Test('.*', 'abcdef', 1, 0, 6), + new Test('^', 'abcde', 1, 0, 0), + new Test('$', 'abcde', 1, 5, 5), + new Test('^abcd$', 'abcd', 1, 0, 4), + new Test("^bcd'", 'abcdef', 0), + new Test('^abcd$', 'abcde', 0), + new Test('h.*od?', 'hello\ngoodbye\n', 1, 0, 5), + new Test('a{1,5}', 'baaac', 1, 1, 4), + new Test('ac{1,25}', 'bbaaaccccdd', 1, 4, 9), + new Test('a+', 'baaab', 1, 1, 4), + new Test('a*', 'baaab', 3, 0, 0, 1, 4, 5, 5), + new Test('[a-z]+', 'abcd', 1, 0, 4), + new Test('[^a-z]+', 'ab1234cd', 1, 2, 6), + new Test('[a\\-\\]z]+', 'az]-bcz', 2, 0, 4, 6, 7), + new Test('[^\\n]+', 'abcd\n', 1, 0, 4), + new Test('[日本語]+', '日本語日本語', 1, 0, 18), + new Test('日本語+', '日本語', 1, 0, 9), + new Test('日本語+', '日本語語語語', 1, 0, 18), + new Test('()', '', 1, 0, 0, 0, 0), + new Test('(a)', 'a', 1, 0, 1, 0, 1), + new Test('(.)(.)', '日a', 1, 0, 4, 0, 3, 3, 4), + new Test('(.*)', '', 1, 0, 0, 0, 0), + new Test('(.*)', 'abcd', 1, 0, 4, 0, 4), + new Test('(..)(..)', 'abcd', 1, 0, 4, 0, 2, 2, 4), + new Test('(([^xyz]*)(d))', 'abcd', 1, 0, 4, 0, 4, 0, 3, 3, 4), + new Test('((a|b|c)*(d))', 'abcd', 1, 0, 4, 0, 4, 2, 3, 3, 4), + new Test('(((a|b|c)*)(d))', 'abcd', 1, 0, 4, 0, 4, 0, 3, 2, 3, 3, 4), + new Test('\\a\\f\\n\\r\\t\\v', '\x07\f\n\r\t\v', 1, 0, 6), + new Test('[\\a\\f\\n\\r\\t\\v]+', '\x07\f\n\r\t\v', 1, 0, 6), + new Test('a*(|(b))c*', 'aacc', 1, 0, 4, 2, 2, -1, -1), + new Test('(.*).*', 'ab', 1, 0, 2, 0, 2), + new Test('[.]', '.', 1, 0, 1), + new Test('/$', '/abc/', 1, 4, 5), + new Test('/$', '/abc', 0), + + // multiple matches + new Test('.', 'abc', 3, 0, 1, 1, 2, 2, 3), + new Test('(.)', 'abc', 3, 0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3), + new Test('.(.)', 'abcd', 2, 0, 2, 1, 2, 2, 4, 3, 4), + new Test('ab*', 'abbaab', 3, 0, 3, 3, 4, 4, 6), + new Test('a(b*)', 'abbaab', 3, 0, 3, 1, 3, 3, 4, 4, 4, 4, 6, 5, 6), + + // fixed bugs + new Test('ab$', 'cab', 1, 1, 3), + new Test('axxb$', 'axxcb', 0), + new Test('data', 'daXY data', 1, 5, 9), + new Test('da(.)a$', 'daXY data', 1, 5, 9, 7, 8), + new Test('zx+', 'zzx', 1, 1, 3), + new Test('ab$', 'abcab', 1, 3, 5), + new Test('(aa)*$', 'a', 1, 1, 1, -1, -1), + new Test('(?:.|(?:.a))', '', 0), + new Test('(?:A(?:A|a))', 'Aa', 1, 0, 2), + new Test('(?:A|(?:A|a))', 'a', 1, 0, 1), + new Test('(a){0}', '', 1, 0, 0, -1, -1), + new Test('(?-s)(?:(?:^).)', '\n', 0), + new Test('(?s)(?:(?:^).)', '\n', 1, 0, 1), + new Test('(?:(?:^).)', '\n', 0), + new Test('\\b', 'x', 2, 0, 0, 1, 1), + new Test('\\b', 'xx', 2, 0, 0, 2, 2), + new Test('\\b', 'x y', 4, 0, 0, 1, 1, 2, 2, 3, 3), + new Test('\\b', 'xx yy', 4, 0, 0, 2, 2, 3, 3, 5, 5), + new Test('\\B', 'x', 0), + new Test('\\B', 'xx', 1, 1, 1), + new Test('\\B', 'x y', 0), + new Test('\\B', 'xx yy', 2, 1, 1, 4, 4), + + // RE2 tests + new Test('[^\\S\\s]', 'abcd', 0), + new Test('[^\\S[:space:]]', 'abcd', 0), + new Test('[^\\D\\d]', 'abcd', 0), + new Test('[^\\D[:digit:]]', 'abcd', 0), + new Test('(?i)\\W', 'x', 0), + new Test('(?i)\\W', 'k', 0), + new Test('(?i)\\W', 's', 0), + + // can backslash-escape any punctuation + new Test( + '\\!\\"\\#\\$\\%\\&\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~', + '!"#$%&\'()*+,-./:;<=>?@[\\]^_{|}~', + 1, + 0, + 31 + ), + new Test( + '[\\!\\"\\#\\$\\%\\&\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~]+', + '!"#$%&\'()*+,-./:;<=>?@[\\]^_{|}~', + 1, + 0, + 31 + ), + new Test('\\`', '`', 1, 0, 1), + new Test('[\\`]+', '`', 1, 0, 1), + + // long set of matches + new Test( + '.', + 'qwertyuiopasdfghjklzxcvbnm1234567890', + 36, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + 14, + 14, + 15, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 30, + 30, + 31, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36 + ), + new Test('(|a)*', 'aa', 3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2) +] diff --git a/packages/cel/src/re2/__fixtures__/nullsubexpr.dat b/packages/cel/src/re2/__fixtures__/nullsubexpr.dat new file mode 100644 index 0000000..68d9c99 --- /dev/null +++ b/packages/cel/src/re2/__fixtures__/nullsubexpr.dat @@ -0,0 +1,73 @@ +NOTE null subexpression matches : 2002-06-06 + +E (a*)* a (0,1)(0,1) +E SAME x (0,0)(0,0) +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaax (0,6)(0,6) +E (a*)+ a (0,1)(0,1) +E SAME x (0,0)(0,0) +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaax (0,6)(0,6) +E (a+)* a (0,1)(0,1) +E SAME x (0,0) +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaax (0,6)(0,6) +E (a+)+ a (0,1)(0,1) +E SAME x NOMATCH +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaax (0,6)(0,6) + +E ([a]*)* a (0,1)(0,1) +E SAME x (0,0)(0,0) +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaax (0,6)(0,6) +E ([a]*)+ a (0,1)(0,1) +E SAME x (0,0)(0,0) +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaax (0,6)(0,6) +E ([^b]*)* a (0,1)(0,1) +E SAME b (0,0)(0,0) +E SAME aaaaaa (0,6)(0,6) +E SAME aaaaaab (0,6)(0,6) +E ([ab]*)* a (0,1)(0,1) +E SAME aaaaaa (0,6)(0,6) +E SAME ababab (0,6)(0,6) +E SAME bababa (0,6)(0,6) +E SAME b (0,1)(0,1) +E SAME bbbbbb (0,6)(0,6) +E SAME aaaabcde (0,5)(0,5) +E ([^a]*)* b (0,1)(0,1) +E SAME bbbbbb (0,6)(0,6) +E SAME aaaaaa (0,0)(0,0) +E ([^ab]*)* ccccxx (0,6)(0,6) +E SAME ababab (0,0)(0,0) + +E ((z)+|a)* zabcde (0,2)(1,2) + +#{E a+? aaaaaa (0,1) no *? +? mimimal match ops +#E (a) aaa (0,1)(0,1) +#E (a*?) aaa (0,0)(0,0) +#E (a)*? aaa (0,0) +#E (a*?)*? aaa (0,0) +#} + +B \(a*\)*\(x\) x (0,1)(0,0)(0,1) +B \(a*\)*\(x\) ax (0,2)(0,1)(1,2) +B \(a*\)*\(x\) axa (0,2)(0,1)(1,2) +B \(a*\)*\(x\)\(\1\) x (0,1)(0,0)(0,1)(1,1) +B \(a*\)*\(x\)\(\1\) ax (0,2)(1,1)(1,2)(2,2) +B \(a*\)*\(x\)\(\1\) axa (0,3)(0,1)(1,2)(2,3) +B \(a*\)*\(x\)\(\1\)\(x\) axax (0,4)(0,1)(1,2)(2,3)(3,4) +B \(a*\)*\(x\)\(\1\)\(x\) axxa (0,3)(1,1)(1,2)(2,2)(2,3) + +E (a*)*(x) x (0,1)(0,0)(0,1) +E (a*)*(x) ax (0,2)(0,1)(1,2) +E (a*)*(x) axa (0,2)(0,1)(1,2) + +E (a*)+(x) x (0,1)(0,0)(0,1) +E (a*)+(x) ax (0,2)(0,1)(1,2) +E (a*)+(x) axa (0,2)(0,1)(1,2) + +E (a*){2}(x) x (0,1)(0,0)(0,1) +E (a*){2}(x) ax (0,2)(1,1)(1,2) +E (a*){2}(x) axa (0,2)(1,1)(1,2) diff --git a/packages/cel/src/re2/__fixtures__/re2-exhaustive.txt.gz b/packages/cel/src/re2/__fixtures__/re2-exhaustive.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..4482caf9db402edd18e107763f68b06ce40d3c32 GIT binary patch literal 1195382 zcma&NcQ~7U|Nq}!9WGULXjQG&YE@Cx7D|<(Mp1iIQ6oa_5~Qsvs`jc)?HMaJDOH=8 z35iiPf=E&;K}5dkbzk>&-@niA^F5C5e~u%LGw1t#=6t;$ujljm;*I+APxRT$=O<2i zIZBE;zIL|r_4aY`a}@J=?PKfi=r8IZAtU=zPFCu^z2r*?J9|lK=@$<7Wh5kDI>_4H zcW{t9u}Rg51uCYBM(pjF3K&l{-Fkn4kF-AJuD;Y1xDsRcHH-OFLS|FPtLCz}G{@AF z)Yst!qk-{OLBs6*Z-=O!+mCAmqUC#o;-heI3W_#J+sE0`@U(qMHjPZ%N6<*LgGLAy z0indwj$$G0M?@MPa*Uw=K|9`~1s_AG82B-QhJ#R3X#`uE2mSx|QM8={8X1}c@1W5j z`$rTCjkX6lQlZ+?_E5c01mu91hJ({EG?EInk#^JwQK2Ddo`*TdC>jw?rR*K?(n#X8 ztsL6%!f`6?keB8qcQm+oL?v!hiGiua#GPQj4t?=h6k%d8IIvwG8cSAQIC@Rq!N-zw z#1U}FQEG2aCNIRhLs|TwZFT8OEWAZYWd&=`LtEK0P3^U{u0rUCgzPTW@j`rqkEZsv zk7QzL+ed*2B6;TwoHj_mH3$`Xyff|@cU(3B7_!l1jV)z+I#%*-)K~L5S0}RKc;X++s$%9E)*6$Af(3M z59a);f3B}_&5%}0wh%^PAo#pD6!?xU)Ad)eybB9XTl#b7OMAm@&2O~Uzk06oNi
n#ljcuUw^Nd*^HYznUjeU+%;iBxeyn)#$j0)t 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

!c*cDl7XMN% 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¥Uo##5z8s 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

pZhGe}V8f$mmxL3n@?F!s z4FK_4uC}*xJ7^CeOaMJHb5T}8!a(YDOHY-=i^C7H9_z$)hwc4+nsYwVY1V-2?PXUp z94!1}&kH`r^iNpN>_?pJlf4f!BGnNWuABJHx=6%32lb0Kkc!~5ElqUc}c{(7~u6m>GLU8fC(l^1o zHh`YJD|mtQlr3K_aY=Est1>fGi|*dnrTdz6nga+%Ae5KG1ED-kAi?M}>0bWt=`n~0 zxw8?WJL$z6M2 zJvBcTgtG#Vm|Dq3n1SNJhodSeF{4-y`!yQA!DCO3Khuq#lMyU!T50tK+dc~{x7JWS zzo{+_R7XaM=6e8u+sp^ngQiqw-@k%bIkO=LxUV-jXqV)bT&~%kXHXI=Bqhu2>Zf{I zUNRDIkL@iFrQt6$?F1)oq66=ef?BV<3Us)AUzRm(cvgM4Qmz1CWPu3ahT|XtC=DQh zd8B=c&HZLW^W^sCxbr+LK}PuwZPJlr?p6-6)ebY^^udDD=Y|sNZL9rW;Q`dDW*KS6 z_;&-V4uCn2>SCwLOo>wzML3LM4Eu;G@?R90u1q3oOX>LJO~MKNRj}rw4rxlb3s41XiLyYWh^}YK-Fe)JVGI3Eo?kQ*oo0q zkRqm|A|BP)qRIAuldV=fB;swE$$z>Bbot-8>TWyB$M#QN6Vy%JZjuyd%d5Ev)ZnrFaqV{H;1i)d5JODy{Y+3Z$@ zUkEW%kC_w8fIIcu!C$1Oa|5{{T%4M1T#Kx{bY=6`ud$Plq}GF(M!pMTgC>@jwCwnJ zJC#z}R#}iQj}*}TIa3MUTjtZg{U`H_Fd&rRd})Zi(hl|;E$FQyoN25pw@`KR?PqH7 zj>3jrATxLQZs@?Xdljcxzr;e{>blF@+Ucd;Yr`0UKIyJFd+MNTOl@x`ja*mRe)bVO z!vG+Wyc$O7}57Bo`2iAdeTfHIs-bb)UR$h zjMB}wKU-X0?KLkQk-6Tn_a==#1P>cG1Xz=^Bw`?L2blaZeuv$&Ch> zpKJU??L8>vSdG17skm(i*}R5bPE^kiM)}L4&F4NqO>1v=kVh zPT37;*>zocN^ES$3t*;9{KuO=6%?<35jTMMHDe#a0K8j}9Xfluvizhq|Bf0B`<8~w zl%Y!(e?5m(8{8)E*QudXe5{y0gpdy|k%g z%Rf~Hu(szDIaciMsRfVm-s^139=OX6V2}*BKL5y;WEZac>#;z@3MO9V4UlfF9=Vb8 zi3YicE%NWO4#^g6T3e#+_U$$T);N~bBh2mw}?NOTW2tUxj|xdC!N&W z;fNfmh^z^80h(l?FascN8vA506Kx~rB=djQ)2C#x zo}OuP=p0r5cAPx{;O?R@Pz`^nXgxh;DVpllvd9cSyyMfCTI~N;L*Y{-z23^4!J_l( zDimz*BYD>wrssq6p*G@>w^e?DrAAbQ#;>V=)xpPzdC?@d26%3{g3=ov@_o?pgWj_{ z?D?^Rls9jFU0atcFCw!?3FxNQmc3m5sE#}?6PC4c6O<4O8e0EJVHs+R|83^q42+4D zAGu^Ce8_+?)a~1yuHHmXEIgGsGnX!XDBa=7>36JAbzFRF|*B z-yoakaMJ_3yZBgJexUKv9MdJ5%L&VycAp(WqH=A4+}WVmC#EXrC8kt<$|AJNx_bSY zGXpV*KHhS&3h#Ajzwvz6fQ<$;B>MjV7L(ElK-4!6gVlyJlWFtZTP4f{&caSLUK z^H0sF4UiPzW5_FhfDfAS+#$ERBw12Q58^nB9W0Cfo#D-%>C=hbg&Jn>qZl0TY2+k* z{UZuBzurEuqE#`29pPHdV&kK14D2!qY2VN{tmEAAnGcWrlQP#3-xbl1IZaaZGki+F8kzbcj_| zoV%j*3hb^affv6z{=s?jkvkufM;=S!PoHJoN2KvD;#3t=LxwN^`pX!PN0I=t9p?vL zf3f|`WP7%s)O$g}Hl5H@M`r*m9vOPoz({8H$W98wr-^B9YQyv-@kNO7@aSyAb+qS~19Ve4oGv}2l~ zrhbYog!>4Nrq^5Veu#zs_zGNpTbUhho)WLfw~C0Ippe!39GQzDwOv9W)LvD2raL(0 z`eLg1t``e)FBRn?4w6pa8VSD;Y18@(*O{q$9c`D7<~H?lq6ou82c5@4u13|Y0pRv) zD;$staP2lcLtTQPC$4@}1vZ6Ck7X4)(4Ay{Ng-Sn_T1HUvF-{Ili~z? zx0>1$O1dBx>6rdB?|Cju3puG2%=1@xEiO`7N@^Y{a1h?do$vF$I@#S(7}XMJmiYGt z*hBwe$li-6Z1o1qE&yz|LHUa>=|#!aj6v@Eywn>8xONX3=J80^q*SOyp5NT=%AcjS zJ@N4^OI!iDd#mpVUfZ{NY*1o$%Ifo@&}jF1DFZ42Q(>F9$ZOllJ8@m9_I@78y7}?8 zweW*#`INp`UD){xkRAk6(4EP;`?d;FHaxe0h&z-NS|}UR|kdst}zjXS4jh`6NSY ze-dfJr3{`jSbh_QMdu=0@DKAx=?Uij#qZdyM&LY`FY%mc2yHo{aoXMFAk z&YdYx)LZ9)slPCIpAQFtO9{Yu($Vw3v|r<#k#9-?n~GC<0%gn&(Lxu5NoDrMj}y?E zm7So`&;L5&jAYppK7?ASNBl@(5aKps16ztG@ws_5*7gytp8R5<`==NT1RuV-&TPxm zQ>{Ysa_+NXduIV`^rDQslXvBov8R`*Pzm*#t8GTgl9xuUC;TZInJTDPP0?^xzDr_BazQ3A!7O~Tej=# zJ?>u|_@phRd(_*zZ2!1+o=9R!R^W+icYr87OV&Z;R}#e}XzSsW)Tf@43+4!06~YHy zz;0f;S%V$gb8`0wzXZ(gCr`UFc2x*ocwJ?L8KB#dt<}fdg^DdbzKT+ITiBReWPc|w zzcN}Kf4wp=@zP36W@Sb9A;*_F^1k5w&Oa}{PE#`q=FacDTJkvJ)fS&=kRt%Zo3Pw z@%5~D;=V(zLZ0=arV1KJE}Se0Ak^cjTaw%Q%7;1rZpbKvr&X5GMSZt={Va{;Ckl23 zo=6USB45?FK^Qjy78nHl=p7obDztW7Y!kPp@SiA}D4{sF{HQ}SLmr;b%pb?G0b1Qy z3PV(Kem&E^Lq_iY!QibX>W6;RnFC{EM??FDrn?CCRhmnanF~~8!{4;JH*a3yL`Vye zB2l^|1K{epsmRUQFBx|j<&RD*%@Nm*Z(=;!a4>oAuiXGzw(I9#XxaV;y6Y=$$zaiN z0d=iMp^y@q%0^&BJ@9B{Xx&cm6nKB$$VfSm)#JMe?Chxf(0o6vJVZj2<^Kpq{mS-! z08WMPsNmQnkKps&W9>(B)j~K}*EokLFd$O*yn2NBtOK3$Ysqcj+7snuyF=b z8q_|^w_Q~eib-25QO3Z2uNh6oZB zQ^zpYq=I8>4@spuKkc~Ry>eX&0iWAhVqfq5-9WVIBoJ-tL@zitd<_W9s^xKJKDnz< z=!iMTMyEJ@yZDpo%e9jd5$8{_d@k>P>GjsD3fTlZLl9+Rxu*=a(Y|YwcRAXIMf8Hl zXYi}7cFZNN^#q%d()}nI7EjO*eq>>KW%h7uNeo|A2-i@*tk^d z;~u&%Uaa=ySRXlak5r2X{7JPZv>S~MIDaN{-RzB2uWBu)x`Ma$0={3QM9L9|w*e97 z2Td;5I@I=KUdQnI0Zy&7eVkoqPIrqSj()E0e}WJXy_Bm}GjU`3I>Pmt3(k5XGOqg) zIwxYFVK<&1d(n_hn|8G~;7#r~(1}*Yb>{Cb{dJ1+lG*;g0II=eyM24c=v~eC#Jg-e zQa^m_$_xD8NVNqUgs1PAJ=^_sRXj_}&nCYV9n4FzT8~&-^4Dd?0~%)vH6;aid_E;* ze8PmiwxVh=!C>^dzjcBVV+)|F7BO~YAjjN>DE({9zb zKA0s@uK(0-Dt{I#rGZ)P9%%5;|pzQflv8Bi~-6Ya^?tE{*mmeAOu z#ET;;3?ef;KVRLw&FV#6Vsi;cB6RQB_kn)nc~wr^&?#k(?&>pJ&gEKBK5L%>(nD)qXi_ zaf8JTsV1nbq+ywJ)M7rqEi9`gA(+DxH&FiV+`KT*#t3<}^FWtCt7xxTmt;VailN`W zZduV5syc3vKmswgk&CNLhyyy0?JV!9TxV~|Uvq6Eq`taU0^_?hjekzTe)x%$z2M?5 zWEuJsgH*I>tp{4{%8zwy3Typv(piS1od?aZP}1Js2J5F%yz%llAx09VlD#Buu(ZMI z{iY%;&Q0Bd=*dvKkoAi|1a$s|6_nqHvG^kjQY(zWPBYhY?T+_tRCRcmdh z8#DS;ezV9L%>X){bWZEH@uz_|_ZOcqhS(cEmxm_c1A;vr5 zyNml?&$p+V&T75PYx#4coOiQ=`#sdB;>uPtOU`ct_&B9WXAp$6n}Zll^)hY*jW0aC zHQ(7-x~Cyg_Q4E=0x9SKHO_NT&GI!ZxIoUlrN3YR$;6;%7|3Lvwgjs zw-%rb+1ydsk+MTX@I|1=FoI4frALiX76!R$4E5kJhxxgc{#JsO9nUlJZn3Icb)m&ZOgsc2?>DxtmK_noxB>CU&F^2ZeCn2 zyEBrA?${(3j?zr4E3Gl1ljX^|DP)sI=XY5%PC_J}0J(AVw&BX8vd=CP8(cq~2U*zM zzrQP1Cmg4ZE1e7KvASaH0fzk$+{4f>^skZ(L5uX#3c3`mLav@!E|!FVwvtW5~if5 z9e!xuo9ND&w;#nHIvMX4;%yu9DqsaPla=E(R?2N}+yFSPkxLa|JPPzj7@I?rHAXEt zFZ6G!9!HK5rz)&6%ogY7IWl+LH1_L;`In(Q-z}+9YNk$MP}+Nf`vi1c4Da-0$Wy;b zJL2~M7}^CSl|H}Y!ulIC<)a_??9m4(8w!IDqw)4Q&J9HLFkCGu&xTuD^8FBL@b zoH`RqCoat-R+V&qge}J+?em3m6!;5nkho!;1la5s+V+8TQgNM z;^11STV+eIzgRhs5Gd(CX*pT^l{6-nSZHG%mCUM4c3Zuy@=gRx%J`fM4r91!7-t8D z1i8W@W?d)}9zzxHlM|zWI50HhGa962h^x`Vtz$-4`vcLRWcG{%`5!XwuM^=0JFd4v z17q&Oef;PXz_^}hrFk?UvVNbgJglxP0a*aKw8MXMY41GyJkkHjrOl9jS;M*%gfkw` z#Q9o=EIYbj!X19sFU=c0hJ>Eje1;&QC^j$dn^xvW-J{w_{0&wQ2pDfHF1VDYB(1@) z?le1I7WTVX=bCruQanbD#E9thz+~$Y)<8k~*t~PjT)Qj;h__2kszb?zE$OOu1WBMG z35TAQY{B!1pU#fIf_UcMz=omt&Vk$$^0qMud-m+gst$GfC4uDau)vTIno+RPH+(34<#w##TAvnK{NlkXI8S*Gd6|;4MZVLxZCG@#c6JAaakQ9Ip(ihAjK|Q>ytM9?Yfl` z8D92FKjL5M=@R*=acVRdH>HZ=qZiCmk@0`)1+lF3@i62l zfW=J_cm%6<`k`#!7M03B@p0EK-DS!Bm&6;_;qh7($uC?(6Wr?Z=;g?p_u@-XvlTBu z-9_wwooSc45qC8s-~X{^ZO0Hv0NQ;Pr(Cu6=NE}tmg?HmBTSMhz{LsRD)&`su@*HT z&bQzdIJ?{9m1}-KSI@tCu-Y#FM1Tz&K6YC7yYF|Od_%iBey zp}_2^pzFh$?RCo;QPS`y?XL4q%&DtZp~u{S1MDL3^Ymh|WH8Bw?{M$_OKHH}Njo$iypQCE}6U%tqX6e81I60R*_~`&GvrU;^KnUuJBjE5SkItz_@2MLkS+q;jST$uE zGYrXonF8f5m@eu27cz=m;|7X}E7rhYp*O$73j%Lhkwfo)Vj?p>;|A2dVW2)LXlDKv zVB^#^;}8kD|DI$|-tf;!_6PsnB>Tqyd6M0mb6)d;xA9(Y z9$oxB!`NnUEs5dJpJPud$SBU2v$){qLAkddT;`hx0(2Ss`emORwf!i2mS1rD(7bE@ z*{yaiFm8DeH=q3;%Ytf{Tt99N&Q5(&{`_^*86n)qFv6OQIFO!;Enc*3^u0Nk=oW!| zn=LYQrVEOpoC}L6-JXbod$y;L_JZtO@WbA_63L+zcZ^gqI_fUGLOdgqKf(S9F#ADL zsX-#6UZkxjx_^089?-nQ8F(6YNaS5vBKKivlug9f zUyD6)kGjUQ?;)uzl5N^^?*vNm3XwD>9UAO94bc1}hZr}TK9yDE@q=1LKaK)Hk|-_h zqWQRyrk7YB5auW3x=gHHrm8i_mjsfwlclMS^pvFd^YZ<#Jnk$O`CM(J16W@oi1iH( z#0s{7=pny$XqcUMfylZxTvTQEvIs}b!#i{0@dM_`z!%$%Xjp$5sq;14wENz>qV0RR zCAL};QBvkHUCS9ag3IQArfy+VoQDUr{LS9HOGItjvWgBaV10132GPPHb!g=d1liUv zdh_*o!2cJKNoS4+HA4Auv4V5Jrxao}(dn`0n%m2Fl4lI|)qpsiMNaW^%%x?2rL`;! z24>wMuN=DhFdE7p`BfJF--Qe;HF;&$O3?36$Eyk3MzCsiD}X#L5DEhF3*Sb{auK;m zyZV2X**%lX09}C(?86{cjZSzCq3qL)ZM0cQyIX~xUzCW{=2u&b<={dHsiS{Qu?c zsLMDV0?fDzRh|r#Y)As=H;{*SVahd27}x*-p#OvSe`%>~Y3y&7PMOm-+fU$u33q_^ zkKx!|5T(R0?al>+2G>>j+$;N9bm_lF**F=iVwsx;T%MN6cNdWM-<+EmiC`_@4s zFWy8>BkafLl$3RS^Uqe!0hzJiN}E!46w4zm6j3~IWW6@~R7$qP{GKwt`QKak5Srt+ z@$*CQmZ(Z+l0XbzK(a`zQlUO4O6wUL+b9?EBtrZY1tW87AN52Yr7rvhY9Ah2;we?0 zWsBEB#f|D(!hVJ8 z`vLzbn2&eu3jp{msaKZ)p?1M`2(1NPe{fj_nKhrji0-d%A-sp;tPF03uZqa-4|hHP zu$Yk26!8lv=Y5j;KLEZoZVlOk@*Q8yAA+|!$Oe*Xe4Hnti{sIUGHK-ggqz)-=MiGx zMV(t*$_X4H9_>7LwGWq1ytflF6}Y)fe}m}cUOR8J9?HDHBttyi_>f|VYXysaOPIn8gUQVU)@ueTnA}%9?>xE-$o}&=M z-^hB@(dm-sOei~NulIan7wn#Xp?w-9P?7{h&f=qYglG-R%{{GxzK_0GV0sYXlcechXZhTKUCDs10n13F)xz&qzy$ zz)7Vm5IoR3o>-QNi|)BiDrZZ_oET5?&_Ir;15q?5ZYb40oNUia+9G~r^xR!YODQze z(`65KeYY4xLawn#d2fW7Gn{cC$dR-PFx>CL6lIXaLyS%0ghiR=LtC`oCoY z+}C6c6T*#v=&jLX4^`K}LnqAnH~@_*$A4`-U;Y~h@W9wu@e&br8H720lh8z4E0Ev5ru{Qla-cMOInu9(3|5Ena0m zxm5#=bHFIv+RBIF8#!JPmN*3>nb|&XfOGG+*4&d(U-R?+U+6GUJd>j`Yj8wnd0|Du zV(>WgQ&t6#h27rkud#**(QyrNaB%}$YXF?n7VXap8SuP{G&$Z7_Papmgm)+@UfGEB zztnah%uaS`>7^K!vY#NGpZYkHCoU|V9hK&7*22sWS*cxrBk~1X%RY!(=NWA2+(mu& zkMe%*Xbp;T_cut*)o=QlRSYDl{6Vk4aU|+o!^P48ZMYeG&o`|UOFQ%YpbEP6tUIVE zX3wJ$KIQQw zS`KpYkB!1%G=R|$%pA2e=t9?yUIYTpChD%l=sHf9Jfn9vRaB7#`?2hmUlUQ*Do|Cre*>0S|3hK#CP^;;65rHl}cy% z$s#Hr8$aJz@pl>jb`>n+#|-w>0%hFU94O=Y|53*MuN-6qKzZ;WALIqaW_cevkgh3zAO`}gyX@9L$P58#yBx71BP zj*GCb9~a;^o`C)Y%x2QOzvOJ zAo!M{EBUNU(hJl3mp@k@vAg2&jS|K>KYVf znwtN4y(cj&JA4IuNW#Agxyb3C_g|W`XU8llw=Ho!GpeeZP0JOpE)jUfbCgAj>umXG zH;~l6!tMF2b2a|247^^7=bdE+KH-zo3Ik8$z*ZReUpUxPpCtR>6IIvTz!c3C)h9fW zvm_w8!Mi6#cWKeJ_;{p=a&F}s9`wEnkZWb`C=?_%n=sAsdqY{8M~dypKjf`RBu%z) zwhf?hGPd1BXBz@+#|zA%8SLYh4c<1*3GkLT*Q12-{UuoQ1F_hD=ywAjwy2`Ss#eo@ z>GNWZvB1fWOHIgS`P=H7P9yC)UIY8jz^Z$H&+?K5QdF5(Crv%m0NOUd^ngjb13mVh zi&fe}o(75<1Dgev!&ts$#)>0ebHkl|&SW5O>6q~?#8D*Wd zE{`0yNss2owqAK>Cq#~&^l9_{eUAMk;Y1bLp}ywb1!D&J-o{bZ6Sz5GaWEdDh;*TM#dgG>s)0FU4~z#_oT+DUOg z+GnT?wp;rr{Yi9R0219ZZ+N-aDGlG9BwL&Tg68L4@L_4%m|_a_O`zB+>#lV?f-A7P zFjO!5<~RVoYc_+>JHV^{NNWZ9vy2qN5!KbXH*V)vHCe{Dpln5R{U=Lp;BGPLpZ5N) z!kS;VsS2kB|aTI ze)!=>xM!YxHrb+edaVMTbUW2RRd6*#GI%A-y`c13QU1fod9|7A^&xMwR}Za;>5RPx zjF9bg>q`O5J&RgM$dC}Du6K(C>iw~IK1p2mp6y_md)Lg};>=MHbl*7snVaa=Gk^BT z5B|rtx-?H$>Xh<@(KitrVYN{Ox9hYY`07d>Cky3McLU@c@V}0C%viRBfIRnD`^EiE z>%Hoe?xu)rDRx^+#_j|i1psmf9EJQ``yp(gXX!I!Bh#g2SWDJKF{2_XT#!`gzypT+ z(<15qX!!LYfNzIB&0tM`_!#<=9|%sJsjX@bB)?+54#*4)QcKxJ8BR~Brw~&sN~?z4 zXj|eK?IzlPGmls|wsTD^~oIXX-LiC9QMBfFff-*?x;Vhw=vPpB;>Ys zkHqq}>Cp$T}# zp9i@6;WJ%XL@u6cqyI{Wx2lh*!N~k{CBfV+4V*E#BH`X&jZ4?0r<0|+aI6lLu+0TS zZ%n%9f9yE%zf)X6GRI8!6zC6 zACR~Lz?q$6_F+6h{w?Flsf~Z_=q8E_)2&PWLt4$^t7B~~V8F19Y0}fz7-`w`i8K(J z`KxPa^wv;)i*3u0=|;${yGk9XFt>(1e7)~K&^MtR7i(gF!lw*fHu3?O+TPcGxf7WY zWxCi3>Ye`s_9nSRU7TK)vFCu0)>sy${4+2dHUbFQm<)TzSTMR|RFWKYKs@!?s)IGK zgGOJf`*l`tL2PKKzzi6VKGUKVXCiMO zs#Y@Q{E`J3_WtRG_7)CrKZ^X*FHb0-OUHXZb>6MEoq!4zsH#yCLBtd-2bV>j+Xk$J zbO2UD3gz5}FII*rVzpv>H2WR){YNGln_9Q9VK&zUR<2ky{Nq_4L;GMY81D(to#F~j zos59u{B)%5QpD9UnYw*8D5n&4RE>Zo*;gho z&(liFFL#*eiH9Q+R9q$q9evcTIsJgrx2Dk=AayE2<`1{qtagmGwDqKvK?9P4(ipGdkU&BxlH zV$)CV`Td^%_@l%jxu8f9DG*vCB@#CC*H%R^!%arAZ)1A{2(@iw7kBehuLdDqB1AXhMWD@q$&ye$xAHG(li5#`vnR#n}^Ixmuo}ES#U(SQsYh)mMZOR^B zX=}yhQlKNiIP05y|Ej7(*jc446mNk?AlUdW67Z&UR=MmIAc8Gv^BqdLH*x8Az?p%K zZB~%}kvndrvLaKu-vjmU(C5ZM>iW2Jx~T8{{8qPnv)P3<5~G)_*o3$6+*;a3U~}Qs z=Mu))KEzw+WQWm)ua&p**MXHKp8LCiNzuPPm~W_4EVE@rKIXN*@0VolS#(Fk?+_)89*ad2!RQ+s^^PM__XW z>}vu#oH?Mwu?ZNs@x^Us;zx(Ceze9r?owUXRgaO;$t6ka#yi~d4B6TC8sGPB#+EsU zxuy*uYKC4d0CI5;K`!pjOyAPNT%;Mq^0nN#1B3>`EJ5`$3A*`i07?2Cb1{0VV`sAe zjk}}U%8~{wW@HxbC6w(i{4vth?_<6^1li^vJz6!CeaYiVCXT^@OIqwp-qu1xX~p*r z_{#?-{#5df^nF%f6qPA{;K_I5PKxy3m|8d))2HaUr>h_W|8q9@eGQT{pEn*yD45EV zR}k#H!N`?9ap9i28$SGul+9dTYjAyaGr}$zB#_ph3(NiP)N;G8aX}m?y}%<>t}TUS zDu9%c=D|MN>UuQ4g5?55~Qg=uz!maSDm(J9W9F+-oNOW6= zX*}vmr5--CRJemRqn!T)2xEJyqMdALxXqFNv*fcA#sFAd6$VdO?901Xanrs55^w@Z zXK-QP$?dj&w!KGDp-(2+^4dB+WG^v_WR`{|%l39F27*)E)5tGl`he4NvGo&5nSn6q zVx)(lR-G$;!s>|LqGhhR5ljol(FnB7-!&Pr_)RxUep;bC%9mi>3LbC=_R`247QQ$x zfb|LU)$cC-_wWZkSG|(rt)0^AviZOT5BK~Y@L8q7yVurUCdF^va8h8;0rF5{`9Z}#?N0v_0@9Y;xn(V{pRkmZ;j?$w}aU9C%Z2} zE_3_DT7;N&^c_FO=q~nk#)BJUHQyRvghMe?o{<2o2@JTX^E22yPD>Wn(IEdFX=XrH zj^_q!?;lEh1tzfhl6Hb&rP^AkNq9@E?dRltg#1PTL3}6S|NZRmdG}g;6L|-)eyYoL z5<#2S_be82usEftt5tS6vWGr2D3Tu_R45>%}kc!U; zUPO~MTeu`b%XZ9L=*!JrRn7=j$#$7rtrVF9rA=|Bl zbK1cbWl9)1rppDr^S2-y<_Ea&iKHDv>Y>MALjBy*QKj?qXztQ{Q@6__7T(V|k@cYM zWBOGoBj8S9*BduDIM!#b)7}VoCUsm1eZTP0*XZDbbgn0Q&qDxx0E79APc`yHUS!Ff zqUVOjSBSpqy&bG=CPffJyVN%4ywH`Br2$7i&Q0jkjWepAL#CM^2-{UJ5eb_c})$gFTCtPm-0&ZRYq z)E7*79#O#LS~vox088f6dw$d=Vm?Ou4wuKf<1ho9TEwPKm;s-GUP)JU&@IvUpNP|0 zyR_1nt8ZAdA_wumb3gE3?=W~AKPSgf5rt>{v@3t9&34aSR3ko%ipuoQT>zF1SAxri ze*(*fo#r{zaVh!Z2|-i-2XdckQ)qDNzpvXf9&v;xM? zBQ&~p!do&QfXs;5{&}y>X+!l|Q_lBQ?z|&u6!2&7@kq^v_K{E-gzDEh+9+LDHnhA% zOGlSRF`fPaC6*4sB}3chx6zAJWY?OWtav@?Y`mWQWEtBMMujt9(x+JW9Z~|+K*B6& z$JzCr+R0{JsYx$}de7jLZ-WX)Ga`iB&@Q{KVPO7*ZQGm7MGXTCyltjU+6GUbGUAq= zI`euy9WiT0!8t5LYjx6&{biQ^;*P-vjGz~1*DHU>Gt<`fJ0xKgo*`fo)-`WpjRl$kU~9ImizR1rr>2kWK!D z$L&e)Nd;LzK6uVKK5dSR`*{8e_XtnnQGjrL1?j0zRU=7TzlQr&(_nOQ5xVc+Fxf7r z#`*aHQxE@~ov;F~0*rpFUevt2{gu4ood_AyX=ktN?}v|-HgPv9oQEywU(RN3%sZ!g zbVfwX@hjHQQd_`eU=h)8RsJlhyt*VGuH*#sZ-#D%a#omEl)!WCYrg?*nmn{u=nVtDdm9PC0 zB;4C)OPLH`eeTNWD`Pv}|TF<`71iNp$SIon1)zEh$gDaQ6jIfD{EU zF5uj&Ft5A}9y_bO<~;5CJ+!t?%v>eC;sk zZ4+Yhpz-anz}f#C?GhhRZQP1!MV<9XQUu1!h}5pu)mE#*aLbP+<(o2b)%XrkE`-Pe z1e*7dy*qHlkOAtcro`{N{z&@>bch9=V>tLBeO7|mn?f!6j#i%JmXx$zvsLC;`6Tdz zrj_e3J9iW)*Kz}vG)%um#3KQuqmWry@zDettCzrEPVlnuk9U1kDTp+3P0Y6xOPp^z z$NPI0BqX5|v}9*3PM+EAKK-^nZtFTnt_z_E8nFC-t}C!J_7@4)JM zA#haQ+#_4PDgv7)GG0;=WCA|Y=_k91!2S30_B{2xH{s#vlLK|!t{1P5xNC$gt#2T5 zXWr{EtwfuVjv(OUD6^YBBg|ibSRRN(!wxw4=K_mAYDp|l*G`bGzdt;07FW54b8q8z`*zY zzWw|5v5&p~dVG%I?(14{o@<@!%L;iJ8yi<|O~M$%2sNFS)w;NyTDW*?O#wE=>H*e(~^R32tjRGI&h*rzDZ`NF1|#G$iO z_D&8Ocy+iWIe64G4t#>)P!3H@%(#OBT(te1>ejEKJjiXR zqnHMw`SyWJ+oOJlwws9KEOnQD>;P9Q$z9u%q`%c_KlDX=4;Uw#DWmzR`@zIby|E*@z$ZeLu5rA!IvmoxmY z^vhcSt+B07wo*o;o$9QNUy)ZOrH?D7ppc`vA4q2z$6*;qzRBTXOA;y%M?!0)sd0bI zM$_#g`3f0opWcYrNZATsDxC!%@Jr*o^|<>yR*|;LhNe+7NM)J9vcWoL@`XIKr(H_7 zcL{Bd#iZk8%v#y6Q|+S{SvpmhZ3R!*w+nM@k+<;OEkI+8Z|WaLHe~6@Hhzrsr}5w0 z{HfJr+%|$(sS9to2T6N)eInR@m><_mcVYJ3ZQ6;u6V3;bBd+nBb6|vCI2kM$Qpr$T zjD-h128C)oN*pMHwxHe1(}KBI`F|4W%v&sQOo#B$O}zd+Ks>0ur15x{5#AIr+NeKkg)5r?2^ zc{4CsCNIm0EqrTNoi|_Q0C#HS&m~nQ(pOz0_U|Z#z;?G425>N zi~a-jGP~v=s14lenuQo>s2DxEPef4jSn{?33tTV6tkrQdQ%O&D$5Um_2Plt}-=&sd zT(w4a5@n&hr@6plJO;R)3}7ns!$VnA!=~<1Hef0$+#f=6a%8cPq zgfu?hJKQzVEYlcp*8Hw4V5A#LM4Tday9vC6;KQlYR12_-K--9%0*=&cga;X~0L>nvhpBly(r zy!8*L9td?ju=xsR&PWyBW!7# zJ^QKM`*V&mG;H=c?Y63c>PeW$J-&Ll`^qUZf}!oB#D}7R!r*9+3vuo}kKnG%$1)Mf z{_}8!hC0aYqUPBCisjEsz}(}svMoTeC+}XIZ>$9uXooJyJ+NN))!0^%)0NAF!~6Z#L19Q7ACo5{jq^np+T2g1H2aBUKoqoIB#!rKu z-(EVkgGQ$1po1bCdqNQhfPw>L5Ie1%nze%0jcX+Ji&j=kX}l(l5ik&=kZo`!)LOqn zM?A%aafCBiAsac|=D&4#yZna^?*>wEd5}1!KLY(7_;iBED&LUi<;);DOY-dTg>;}j zyCgj6v^m>M-M|3Q3{?eYc%C(OTl~M+*xfrw8JF_yxIDq-+%srNUF= zh(G6#*unFG$m#$4`6GrYd^Ron-7KD|Xx0LKETLsZ;OUm>n_tbE_?@y@oHY@gXlzBF z%p0=qYrDKD+uDB44-FB`&z&$ZxQ7*doNowtKKH$HKTjdRkwDh#HRPV{QD(_1$9{fR zEO*=+vQCn|kw-!!WfdhNMpqU_1*S2Gu)$aSdhH>WIbq!0FP;^sK6AV#_+v=Y6}JkQ zd+Lg^Kc$RM4ftgRjD))827&CoRpOl}tKF53U1+7^;PJSEAo96-wDJBq0|(1`BW&K+ zBbrsIiirssp#mP1E5&{_YO6Ifr9<#Rt3c%rpc^@ScbGS^9OC?WQ@KONU{r1**Al!4 z=_IZPn!$~uot{ylq=3F$S1P5uh|vE7DdiRP&8w{jB>bT6Dq_wx)l z%LEClw))ph3Gt$0(YvE-zuUgI&-=uZwCkC(Zj1R>J6IK{Y`rhfc2)%nt*PI2Y@(g{ zTZ?5Y-42okj+ow6nXj-xhzjpz7kEbCq&XQHn%XK^(fs8Qhk094%sTJgyqf~Tkra&3 zoF=T1l)~5L13e?y>P0fndJ3nrv1M$0 zE50AvG;u|^bUit^=@jSW_q)nyIL)prbQP+Qz}d*+6!9rSxb`I=_4smpR^)s-sxPBb z&?oPOcCW2eKY3z&u5RITM|&-yt6L=HuHZIyI?xN6IVS)W+QZsuc?*|Mh<%+zhA8t|?cLFaN~ z0vVN5RQ<)({Rb0VK|V}3{FnrtGK^1HU%1cG7(3^a3FV_*sg6=}f>@MD12S{l4T?gCyt`q}P9S@#k{sgxTvid*u+XPm zbdvd#thj6`!E}?zSGMd}4|$s?(E><}vz(Qd9puMo!P#*I4SG_u5mQY?Yz4EJ?7E6V zg&xO|KUYOtui3?&dD;1c!_A6Yct7$gkG`1$p+s(zV{b_jGL)Fj{xueiY-20SL?6Bd zq{VSH@L^~Gmlmc`=uN!744pe~>T~0HE2B%vhG9DosMqU%g@u5B{Z{E1(B}Ws)@oY1 zJs}w6X$_D%pz^AtxP&bywV7_ZfY_3GqMJ#8EkA~4ayINXn3`8LC?0sQ=ECVsI5si9 zKDd;VTX^M|RarF!Ms_mC5-#(W*cH2`Z$_E0HfNbHt`}$OdQqnpB&WOwq#BWUN=QSJ zCcFV+|9YU#Ag2)8&2|wqYt7@z_M4n0pdegMSNje21Ml_(AtPdOWp0D?#&0FS}jqP0SBoZeO0ouBZ8UZTnas9+Lg!aR_bbG*GEuX8E*Q z@^PBmGrMO!YIdI1Fge=^V5TcF|N17We+jbu!Ax%)j}JYFZJKjl0(j{)puuWxtBh#- z7>7O;W6?u(zY+1Tw|<;}8dy@0VJ_7;Mzyg1ZSeK6gmZ-L_^z##+wn8}@4fZojH*1T z%EN2AgD3ehJNUuoL2foZD8U7gVqrbp>Cz>6Fb7lQ$yl~u+;dbc0Y6O>v`PTBcvxe!taKlD+cTo0IQ)i_Nd! z2SiXzvx7;Fxu=f-cHS(^K<932g(Cd9B!5S}t+XOCQJyap2Il@0qJJVod98&p!pT*% zJ6bxTAs8w{DNyK~#by-40ZCQrs>_Re^JPwpyLx+0>^eK%7I6Uj z{cnog$<^#@^8hWL#Prk^BNsY|xXAjqAI?q627Bc1#>30a4s`UO67k*T$9`DIIb%O> z*5+V28YHur8`(H{{}BY2V}y4qPP1&2OFLaQ*Km+43z%TC*IRc`R`}4FC8H7Kf!(mz z5GvkP!$)+xZ8i4TZcH4cGp*t++SyV>(7G`8hxLNT#B~*xYokN_ZggyFk1vSX>4%*?f5Mjw~ ztAuaW1{&G&L!+Uq>D$2k?o;_k@CM6cXBfy3$~(@`zY5=<%jBqNZuJ{5;OaFvhK8-d z!-7yp=+?F(GEEMmx+8jV_c&ndLjd_Ie7-$XbUstm<(lT}E>i8rOiyEspAxHBJ^zMC1U=zA=%6ncgY50^}I*g_uH=Qhkv{+y{8p_=HQh^-lA z^KaO{|~L*SC?6#yW4joIp;)nhGpoar1;76Q_j zfk8-Kz8FY3Gc|qUmM4{j+D_fF#_%t+_^IS8VNNKfRXI((>H4b=Jf|%#xArXP+3|rIyKka~ z1%v;dK@VH3+o%iI)qElM#%?F%n|Y*Dpe2@j)m@5p!VQmAN0$|}c`gv|b;2rq(Dgw-9v5{Ga5IB|l=#7^lz7mQHBdqA?qsS|&3XOBR*>nz zJFF1GTc!;Cp+C|*zsan^?o(km;JqnpaAqTWYwE(efo-;x&C#z5tPp_8fUQ4nOSJs7%f>N zdw{!SE+I7%5tc*cgqY7E-GcO-W=l&m??-{@yXLL{&}>Jsl!MmW5K_|SQ_>c=8};pB zfcTx|((^~>VQ!`K&yk0c6k92oNv!0ZI_zw(hVCl?I!$WR-_;C652VK8>S@DlPd)E1 zcb{#nvr{0lLV;N4J)m<+uSh9-08w>$CU;Sb>iW$z{HB88lYQDW6r2{f)eT_Oc2nY- zj&v5lfRBgqF0f;ieU0>O`zFdVOf*o3U$7O>6kB^X7GZbHD);`c@oBIBfKR)8MFVvY zF10Z87Od|(KJzvwr#Ctd5WO%gH~AhUP>)R1rLx)sB{&DK79M+;_A?CDRwUoq=U7FoSp62b%wj7z&#tIMr3a2%>Z8`u# zhs16o=ZF?VcyWLNHvJ*>7`}oM24C(c_3P?O9M%uXf^xkk#%%pr_OU8-7A9?jh%aOF zu-k0aJsS(Mqn&vEr-Yj=ctuAQMx+%p*t<7t(cI9xA+e_=l*47fvp`TK-5bnBWO|s` z>rhoRCAav|JYL-dn7dg>30>k^QLH}2mvzqY<;*q1$&bBdYrzxBOep?oN)iGb@m|a9 zHf#K9LAf6DA07M;)Rtuz^B1q{xY+Lhhhe3eboLlDI!ET*pmi>GK!MKZ*?0(0!V~ud zH|)4j&$0<9-rDN6usfJI&2r?Z*R8E%~J9YBg0G z_CQPw^w<1{8!XTvf1V*%S@khHu_zH@u4R2Dv_=X?o1Cy|iEnkE1>N78&*0HQU)$>a zbUYU@`EpKHY}9SwCR&IWqM}eIE=*(^j7I`bqYb`3KgY?9bf*^Oruncx$D`w%;oaYz883RsVBnNxvAfUIfMsN#vXXL zjh7zyUq~!L#0(uUSylsV|L6{JS&;BG!4F~nX#SRgKAOihP*6IDCZ2D_N~+Gc!hn-g zd$|1Pp9M5ze3kBDjfN! zB)+^VtOndWQ=%_$F-Ug5OWO7dL6TEwzQ?D_Uqy=-FzgOYKb_({I2X}kIg@MBX2XK6NJUw_kD`4UP8jR;5 zs8f_1>yvutjVLf%_m470$mYcM!wSX&9Wp|3@SOTLBG&rV*s(9F`xAzp^l%stT$7Yn zZkxk~v?c2GXX^7)ca;Pw2#3d)1p__auNJg8rJ8t6uy2|1?FZ(1jC{29KiFU5>f*V# zs<$xbm+*}e&_w*m_XlC6anLw5;(yRUZJ6)H0(^^Do$(0Zs~gJtXdpjaxbc2#f8T%l z=nyE)a=HG3AOT~HZ87k-XCJlq{pm;DahT@hAg|YeZ%3_)Ifj_uO{k?KhLqCYY2x{@ zy(2UKpe0n$<;Z%|ea{7R*G2QlbI)a#ZNYYAL=~j}aI;_(KKS;y7E%cqNSmGF+*H>vkg;6cDi9G-bvIi=>&hneoY7L zvp z$_erxCST28_AjQH;92tKzPGg@QV?wJZ$1}rpwxC9n%*-{xqK8(7NJBSz!6?!vl@gA zOfo*+NqbatKrk^?(z0FFbGwWP6lf_vdT%q3B{n42>yIhWu|QF+(sOn^Z)?7YVNZC! z`=T~Ev z&F1>(bQ0~X&F$aGZHS8W8vJY)##`Efva6965ThUy;e5fruL`Yw) z;g7Ol8IbrEiNS(ko1Upns~(xwSrJ%j^;1s39H&`Nxkd5lD49xGZUg_AuoLi+1XN1J zN`V{X{T5IHKlYK zfQx48kf_hCKbk%|Ts~SAJOWDo*p5~ykA4bPW*^D)xlF4bac!3dRGQRu9rT0kN-^7u z#&!+|8oZVhoE`TMcXGNWrk9VV4{0Zp2f8V znL0ae9+WK$T2~%*?`&*?fuC0A`JJnlHCJ|B4iPSU%SVexdzyV!YvBZy_2b|Vj5T1?wdl%oK_h!!-8%)a=;oW$YE~QQ^XmuQl5-NHw7tp4rbj49QW`(9lx`J?M zuLztKrVz97iYVhQy17$uwO@6KBCVvJgnxJp_8{qWXm)$18tlw`37?=zuE@aQNVY?z*+D@GjM2rIh+^~{(uwD;T@cQP-TdXwT^F0PCn9jmXVw6_??U&QS# zXThsD>c5@Ee90rh9gfRCx%eJE0YQDFoOg%0)2#xv@FJE4X!1s%(oM&q=xu~U@6(TM z!|(B58+g|Y#qu_83SVO57CqdA&Y|*y(LsbPW}Bnm3M(l_i(tkr7mF0jpz{}B7QSJ7 z8wQNw5k@|pQfY+!GJ>k9)%Ell6vB?5!Kn@yLm;Y9!IN8-BmfNgY(#$I@ToOaKF9nA z;@L!b7cq^Py5A`(U^&8kH}Kb^Fb(B5$G->O-+hacNsVpy<=&`jG%4XLd-rSq;je?e zbfq^Z8s+k~0Hs1|2D@VR71e0IK#ksbiqQLhA0<~lAf8~`%cXpsu4vTEJt~ImddqScwh$tU_i7lSsJhsxXOyt%&ZJviF!>D-oAc z9?u5op}RwBSAa9a^z&HmdF+Me!dmAeEdG^)(HgkC=?a8lOOu0=G>v5xrh}m_Tw0yQ zcGWIhK+PsC1M76DX579gkSV?G8PQxMFnnE$D1!q%*H>(`ZqD1(aT@IVG>^%Z3B_HR zl>M#3O;pNWddGJ2v<~Vw{zY%jR)7L>1#q{uaEVeA2UdrOtDH=hsQ1##2j&*1XSRQwQv%NwrPv#oJ2 zc)dh?M1`OjUnQID1<=C8+uOyQtE5Z&sZvtTcOISYsL#k9RjEZl%F){D1I-csKKxJ^ zvH;G>Jjmm!^(Fm6En@uL`{_8B|F-pB(Y*_OhpZhh6|`9FgoYx4(PI{<6ed^q=R0xC zSbK>cMT|aP_Mlj^k#KK^1XmfzrxAuNyvZHCZb$=kFNb3C!LDr3uvn6N=ZiVL^eiz18H175#%4Mg)^%=Z7o^^v4zp_=fETGMpK=mu(x8`4a z9&tVT+DfMfKWm%rt-tpC2*<14?BN&Qk66z3%jupM^N?eEI_o1v1TZZ61Wk{a&lc4@6LR@M z_+KYJ*XR7lb{Vdaf!LP@3QP5A=ZY;0dWxliaam6G)$U;^f@?!1OPzyze0%Ykjh)il z?4LMgg;bvLt{5_P2BjoM3E$(UZaeoR6&m+t#qu5G-E2I0zPCoXt7*!wSXfRXtnB@B zBl~tK=#tLauAMbygIQA}+yaDnFf-;k!_|3gxJu6(uF_+}^;z)}jClMmw*i)g6LQJA z#MwQPlH`-&BTc&h2>~pnUVb;{+bi(OZ`1SO^Y-7=VZq{m{|9A*dVs-xpN6Z`U+5lkI!Bd$PGo8_* z`}SlNnd%OBJmUEmN-ttNux-5KRv>YN`|acJ1(g*YolLcvm%X#T)ICP7%FHy+9C2G=l#+C4np+Pu69=hy2Z&V zPX$)_!`veY3LmYbbYDk^|3~9T#ElLw+!zKQvkpob-q~RvYdXKBBGBPu8|? z=oxL!R-*#a&5c-6W&ALD&ylPJt|#gKJnp6x^Rd!gqmUO*Jom!iZh)UK-TAzrx6$|@xTo_4u)e*ys?Y9K2_D1o) zjp@T!q%FZb@QKc+3H)+RzkWXzBsInKExh`%NdVb+cnJz6H;r=*3zvRIm|tI@m-A7& zS~0?0L9l7}8ayv9x3p-Kd61YX`PO^Aj0srVn)QKg^o{pgfEK_J8yHHY46Ptv(I}@f zks=#yu3j~RjA}*%x`L#avi$EAZQj#%k?e}E(m{QO_X;H~gP_(m>CzH0_l#dESFph) z12IzIBgP{?BIT_47??}epS>tRj_BGEdIgc7uSt@@`g$ENm|M?MV`4OfUD>}{a- z;Lqo5p#9pXGAnND{8kNmp}dbiYtDIqr$SZoVwLVh+jTLw$m4dv8FO^KBZEA2T-NxL)%x3SyYlEG%0sU zp#CRx%Tb7UDP}?Qj_&ny)sLP9pOK#`C-T`x41a?`35xd)=GQc|jNkkUizF@WQCOvI zXiIP!aqoZ1dM>1*fb<1Q-&^%4oc~{m4`}5U@fC_9FGE4|tLn?eER`%DXxRE)G z?tS&DNQaLiWEQGI1`j-Y4+p%AP(~8?y|MKGMZ&K_awq=& zhio^J&a?1_b?Dd@{tDL5LbY`+b!x_6&ha!XZudy*NYq&(pDQ3fZ?Fa{t@YT%IcVs5 zm-G6$f4P@+8Hhu2aaj2j$Jm9>#v>~ib<8=%V{@>u!u{Uw1jYTOmVAEplZZ%(YOjh z6x`JCcx%IaCME=GO^fU5jU_EtyX|HWQIPoi4E8~wfx5lr#;M)RoKY4#$y~rj@<{f+ zd`=Ln7ntv;eiVmsDW$s}8p)yuIyjI6n_ey_JjrbCneh!#Z1<(mjB12JOmz&41|}IX zU9Xl)yI%5Vd362amumhAuHD3R`nAlHC{PhKKy=W}Ik~~3Xdu(8peFhDS9drD|71Yp z#CqW5a@0oBqHz7EtWVbkRW#N8VaM8OSMO7RFYo@(jAI|naP}ZuV-dFZ7!;(Z9_>e+ zIZ({WuAfv-d#_0EyXr>^W=BX4fgh|P32G>PIErbmGk!q{JoP3V=||| z-FRE~Gn;{pV;;lV=|?)Jid|bs--<>5leb0;$0}z?uO}e-2MJydUfFv^<as_RN zG}Yi1^{1<7!<~ob8-*UT?84RBG-5)pd~c^#b_yT|78ifomgri9^mr$n0-QI7hAR+)&g=nyBkEGH}?vEnFj2JF(;09EQe&L^`z zU>ZAJ{hGh16#?$$3VYf|F=7-$kP@+0k@-jiFcs1_FHsiJJJ;~%YLOD>qn@`?)8J;2 zHMI+>sFzDPExcoHUlTBq-jC;ac9XHtm)a)nP03ZucQM}AG)w~b>mdVEAli1~v+wPL z+%C(!>r%nm8Mn0w??lGj{cZlN;TJOaw>&=?ks02Sx|!A*a|NT$Q11nmr#5s}?M>NW zkKri}BK`Cj2XUT=8@UcE?H0Z6q)dx^;8Kdtt zpLyR`t&jP$1aVyD8*ayr&|O##0Z@CTpr?R-0WkxouCtsnffqi3*Xbsl#m6}g>@myw ziNd4ZbM0G$H^s|C%z1JES%$I)bP`QGo!d~v+UAJ)lUrRXR@tWCv#cuyl6970f)5FA zY}LF8P`!c1rT>WfixZl&`h%M^dF~N78sdMTjtj_3%mu$b z?rwpTG>K;VjjDp{q;_avJ@Y3jKAJk!69HcZn=vW6^4wWZ?Cc5FWjPJBiQD zgTq<~H+^Xw8e{GN;jr+b@4@>D4XkzFvtY{y36_}}t{2Sos(i?CWjpmJYB#-!Rtl@} zkL)+%mDWry_5PigZP>>{CwZ*V2)*2;3 z{UZIBffa=;V^Ily<^4e!eD5;v=kjLlMYa;onV0`=QM*Si{w1SW_6&dQHWUL}*(fyl zk|@PW>OJ>{hi+9bj;aUL<)_e05j4NIub_?PIJC+?uHl7ul{(%uKz&hI$T$L`8_G9d z%+OEVn&=Y z%33Xvy9v6?JVG$<`yUka(1N&7oh1FH6X~kcNh4g<&L445Jo9b8+m2;DJ(s)Y4%ZEv zYTU;_6&5P(Me1+EH;M|>Y?B6|RYSe6493pheuMm@>)S6!eG{B6ww||Z>#m<3fWDHB z*Z+bBnZR3D@9VG@3&DMWW+OfHAX`+IltUQ9%E5Gd&7za|Qvj37&fKw}uk~Ie#UbU= z7aBLiJkJt%x#*QxPtZ`alRe&5_>E*@2ISLwRY!rVne;Xgu3gn%CH<4fnG z;vJ{PMlbxo1J#kvQNs>D&+;R0MVOSE?VZere;UO){>pZu9g9mkUx_ZsDFcZN(&2k z`t@pNUgdc9)iKT2DV8rDN*uW6mwoz<^4AJmcda1#`!<+<_6fWKML?%CI)6|$z)-zb zx0SDf4K(RuL(QK~BWYOSv9~72V^tRO8*K9Nbe3N}wh4cyjJ?MR7X029x#L~g8ktj- zHFmexT0iQZ+~PzB%qn{83AUr)_80CR(tUW)0ouOaFh${{(d9ious1&UD`EfsNF1Nq zR-#p{ulqLdYwQ?B33S>&Uaq8c?BAos+=s^=*cJ)|5U2^2#Ke+U2fkF*ZpD0wr^96= zMQv$W@2G6yNZO(G{XJ8D?(`3|5p014r;y9erfr80K?!~YNqunll3pwz<|xx!jD*tl z4!t{#<+u&Ld(i=dY{FXf1qxXwX@@p93V9S^79bySqL>BH5((6SiOP z02dL*gGhD*3I7su9qkqou(+B@YdE$Lg`G$$=lV}6Z=6AHYA)mNp0#6&#@lyC^As;WNlJa3M(gE7)Ke70tzK6}djPi^P zyLmrk5E0LcF|taS1=h>CEqj?lRecx~%>%r<<8<_}F#-)$;Qh@slhlDdT7#Qs(d}ts zE)LQQ4#c_kPXwLis9u23#H(n{9KMF_bsVppUTUMxQ&(ktwN69#vzeBvCiaRdxN!br zUq*mM+^rVH6^}3XesLud2w)g!1k;g@xCQFpC>g%xA-+jgLB|@9Y|AC#i^%=Km}IPD zNr$MRpF3c^WEOQ|K%~k21zTHy5|Q*Dpr(nMt7Is-I4jzDP_tjxt)u%tB9s*y^kyOY z=>Hv|T(JDcQ}h1}q3qfemOF<~3QF^FwH?YaZEq0?4Y=NWx0#Iktk7MpFsf5NZ(YW- z16I&q_I_C$ZH@$h^H0!RQvEvy{AYl=!U>?x(>`eBlgxwm_bURB$J-B#-wQ2hqk$B9 zKPcj3m&2}a2CV0`Mv3`e`WqivE?MErn7PHldX^$_;~ENPhkBEa5o=Hrq@I6t0!r7tfYXO~K~Ka++zHgM22DBe@xB z(weMXVD5*Tgi$6+f&cL zVu>bTBC_wPYW!W1i75c^HNamnAgMA@hfJ%ORz)oZk8`nMGUcGMu79s@^NJ2rhF=F# z0Oo&+P-YCbw!!$I4H{b{P@UdzWlN#n+QwLoQ%{1 z+G@4h^fUPWH?M4))(!?eGb`-$eX*4Hw`romPo-`R+weVuuN_X{>$IA#LW24DtiI@w zPxCUWs#zG~f0@DZ`z7qevuB|B8M92Ra3{oV(Cr*l$p6XWV>yB=zwl*6bU)-_HBs%R zFe;m(sN*xsX)tRczv?_Em26sEQ7MeT_ZL|nJc54F4s0>Fmn;-+@+YS!2i?u71#Ah|0pGR@dXx##J5t^v=UqiyjukevdjaPPz5tbODQV%X}km3l>u?9!-80NO|)KEK35} zMZ@r*%fbF;*}Ca!iPn(T-w|($<0vna0+eT^AnZ2-E`e~@{`Qnk;1m7AAAz^a;r^aZ z=%#R^B-$w&@8$PyyMlL5?x(2s7JSS0WyV2mHC**EVeuv%N_&r2nMr=~>!#K+X}{u@ z-3t9jYHxm#!DDg#cYUP(WsVmn)yT6iUe^ZK-cXc9R!;EuU5~C-bwvM4q5jQnj zIA|!VJ|#-%ecuGB;#Eyc3??d0y zGrE4{%QUw;ak zJ;=D}D#X=Y*zrPD#mUsPA>}W4arR$!xy*2Xaim^T9`}io#z~=o1F}%SIa$~Q^y4f) z+Qdg<813&V_f|~i73G~NA**vYejC6ClU(=t|K5QJsm6?>%+$My{g6at^cqvSj$37` zeI%AXR1V_IHmb_R%pFJ1^u{6Opbjp^q=8=xUT-eqE$lSP{ho(^64QmDOnlvST_&~? za|N+12*;4AKof_^wg9T-!=F@3kqL`8#ADF?@4^x>4@*tgwy^bI{Ms4r)*@jlWt!5X zVTo%!V#tX3AK=DI%yMdr?alipKTXb4P$o-xmg^q4mS z9tPLY5%z9Fr|FYLa59P4S zDG<3t)1|gPC%9|TfX-Fyq9N?rd(@-QknwJ54oK8S;|sGN0E*{Eu_iLPYA?DLl=3-D z_`!3G^KqO39d(=B&N+}$Fs|fQ4jqL-c3s9d53mz|wJCJKc@ZF)@0^wZoK~+e4Y%~o zsG00g3We;soaa}{Zr_d1`neQo`rG_Lx$P=a0c(~6STkPPV$2xvm=j(Sd7Bn8a>6*$ zx4TV@^C*z2zg=c6*d%4&Omn!+|pL2b;L^%2ejr|f)2JaLY5QENP23zrEs9_!hnI1A(Q7gd$ELT++& zY8|lpIVGJDUCSl!9tw1y`9p;|q(7V}HwjITq=KjT0Z|!T$W1ppJpWc)l zvdnE2c>w`iTBr7yJb-{NN4gI^MOHU(!zW^dvpm$JnUiRHI=w#h3NS0oL+*ueLcOr* z!5yce++e{>YwQkY#a(SQk@udp?^W69!i~E_Y9|Ys?Kvj40k(Or4@!&@3(L4RNzzD_ zEk#C&paO8xV)nroZE_{ni^T+9>1ss?a}f+to9=I_Tl^Fo1hI7^JRSA-W|Nq;{PDp1 zFx8daWwqP4*TJJ4M>#(^plySLD9d$7JS6)%8FtZS=TfVSLm-QhXxXVFry4!`h6|C^ zgBO*n`%!BjUBDRPSZdR}ucs(Z;dzHtj0qUa;G7jG8q+-^Q8ZxOO0<4dnf}e}N7WzO z2O+ill{!g;=}rx{A|dAgmR0FXH&-|#ooTkVE132~jj~+wEz|ikm*h6{BDR!!Q*>nC za*{&n>y5i3pH3C}+cU`rGL67VJq#Bops)gZmle-qc5_!Iw1%2Rw-JujcdpoU!|A#u zK*yA-Y#Y`d?+go2t90z8#SY_TyKJHDVAX_2QD^>X7wMl|lH25K(-fPE$E#e=m8t-m zvPK9+*bGQ5k(Ccx8r^^Y>|%mzKV4m)(Fqge5uCA;XEr1Yupt<#|3pPl8D`qgUFR}R zu68gRy};ln)Ba|G`N0%}YEn{tiRBFnNGj!x>J_w095--ojywu-6ny9E8L~Sh9=+8+C|;oQ z@)~wMPO9(gJIwew_@U(5cU})xY2;djTw5?K6#$xr#G2QNM-`!of^YHxC7 zZf>Gg73v>AeK2&OK}vdOAT4~;4M{H?_fONc9NC3T(OO-l*wFZGd7O>%Twj2A+Hsd8uAn9Qv`P)L=;gjJs=kU%b%Uq`%U>!*D1=@F3I2J*7{xM$2RB~ zFv*K{S{uSGi!2T0H;89^VT>=l@Z^#u-qfwL69XA8$S`D`0wN^O8F>E&y>Hi)^jnYd zf_v#VgmPh4tY3#0=l)G`J-G-=Z9Bszl(8e&DJTt+ZC@`ltA*xPop2O+c278f`e+8u zDXku|=8+w<`tXLRi}6d-UO;`ctvFvuZiZ-Luz!tzD9ODlMrOa7YkoDS)rcFuSB_zR zPj%z#lC59+%cmN5X*HU7VwHgYCG|Mm6kRgIeHdhCcbVr)-_8(;Q+E67zVC4VF7uue z*DsU=#zSw2zObX=x-F8fSk2NtGC|i~;9aVE@F9(ckL!O@eBt?&tPo^Z`k)eKo0D!^A=Lf9Fq1zy*GqnO8oJpGR9QK^ z+N`Lky$dsXIt{Lwmw-e73M; z%@kF}_>&YJ>74ed6Cr$A602-!bsD>qa~|?Jv@?BY`a*CTa-5KgDXr_77J96X0LFNR z-?zi!h*mPkf-+35v*`(N25P&f=lX!(I(>O=2DGxiLZ^NcefI~;0i|@|jJLKwSbPIH-h_ypA{giYmf0%3RA zjoKR~i7(9FT_HpNV*RQHrl0MrshW4#yvu3KbiRzZ(%?JTZVYj7*~j|=0RHR61pu07lX`C%laAlstsa;c9^Q9$6oQpl(i>>;mKV2hesLn? zZz+PfFT13)p(W1!&6VX83^4roi=uiqqPcgmS<`g*UIcJK zJ1MSL%$G57gXnxjVNpuBqEiuq%j3EZUHx`0)x;{;Oro9GdTF}(JUR$T$SWb0g&g5z z6}%A8fN;7E;r`~JDuTc!YUfFmF`qgj5`2ME_b0<}griK7u zH+1V?_9QD`TB-oToCJMgP+-$sjf;V#oludqla-^IRaAU(`T0uBhkI|M*a?TImY@FS z=LAO=SnpU?4<0n4!5@#T+F7nB&GEg;sXzaeQ0#t~URFs2>qbLvVYU{ZK=_lv0i~rT|~!`6hZP$Y&LHkD?G%Yg4N}U$~d8vX$FcQgk3? zy^$B8o>-Cf+C;%0RxIn&-Ab~l)loW#t|KD)HLHS+seXf#zR3MsM)rb?_ zyUd$PO_ORx3;Zoeo*P=X-+h!u{_%WvstAKr0E5_(>}pcUVH#ivZULNg+LWkud%aFAA);0!l=N|L}ud!YQ{#hnnZ(dD|^ z7Qymay%(&p{z&SrC^SFC>>d@+{DX#uEpLMW)o>;W07IXmD9DR>D(YLb5g3!6kMMM7T07?uu*@- zry4NKd4?kHMT`U8K*-u|XvlDOXzXcQ3U$Djy$cggdoT+?awQ0O#Jch0{3{{dSf z;ui?B{j{9b+GC%7vg*!?W-5%==|l9-)zw2}`0}d_lE}2V$&@ql(4oIORO}@}`@5C* z__B(K4H<_?FUu((J9shF+P7tNOC|j_H0c%4k_TN5+;J69wC|5isPEX7@UD?A@9WE^ z;AMQAEV^HUb#V02D^P+`L}hQ?QZ-|Qo93kuWcyWTxU{b@Y0+)=QfWWO z=c=pQMTDQ;m$APTc)-{nRv58%Yo7rWR3mpmVU$x&BAg`j#m{6Wbk8B z^@F6WRfNCU-V0*FwZb>?{a4NUl2?w;Q-G_`8=8&h#kJO96m?w-plA9bE(1*OGNkM3ps^jc z{gx|L;KhOhl1S!A>~q+kwh2mYDXdc6V(9+T>b=dQgA9%^3-;R! z%fkpf5ia4hKuXG+l`Nc+63RPFUU*md*j0)zFDl3-^z)yEic@v4=*y^-&A()NE_@r; z!b1U6W#F#oeT5N#U`%c7GjiaXmX^#U|o!ix_x= zbQxniR@4Rlt6-z{0bm~k70BX2iOC9a&}Am~FGMBhz;-R@Qr`88x9zr&DLXJ-+b929 zBuG7u=8c3AviBX7OZuA%ehSQAMqBdffod#IL)b4U-sp};6CuZC>w&mCaUjT!tqQfX z<+V0yDg-4YrWg}s`*A%{8IkO5vQp&#tqP=4l6=CY*S{)1T8(!`zVar#+O!vx`CZj; z9786pTYtmTIcHKAGeGK+E9>{S)J1irAh2J3L^XP`D6&g^8{6Xo~cX>hYJM;lP=`rJ+yto(n!y+=qGFq{T4vy+Y{NMv? zQ=w}qJLxydZd-a%V>CBAdqUr#nROI@gUgz!ac4JbJ%y|~NA=VN5*Dq8ItL(D-O}G+ zmn_T^KLDnr&b)kBvx8lEHm^8IDFb^;87*}@nI?q~`gZ}c8Yn<6k)*L_CUqMX9n(rU zp7jMK&?mRQRfF$qpHF$SzzI>=zu*=;g z5D*Ps#%@e+=z^-uGcCUS6ZHXjFOPb8%H;lSqV)32BqFoV)HNMO(f>4q+0kP*tayRH zjm3-J0CLg<5_^Sz0Wo+uZ7Sx>#*y;_4TGcCn;vD;Kd{T=nsx+n=MS-^L|1rtrH=Y% zR&)Li3i&1P*sUT?+d4D*Udr4^0>Iost~7#FSc|o5f1AH%(U(q3*~0Qg*ncs1Y-~}( zK3O-+bQIbA3JOQ*>Bc%X12>~*FJrtj#EjxY&U;{*fmPW-&6t1CUqK$9v?k4F$l@<( z`Qn80m{7UZOyTbsa#Xc+)QEfM3Ru20v9z6jC=8Jx8e`@!qu+=>l>@@{tDuvZia~F` zW%CyjbEf^mxm5dQIb-Z)2POZ03Wq^8f9PCf4%gHe|F`7I0?v6qVM>l0%MULE%V$Yk z+lh%&1$1!qgwA--_JwH`)_XSSW6ah6m!RG?Vhl@-7qprv3llqU+l#!x3Nk7hvS*edDH$^1lVt={tLwckYW3KQnUk*_5&EGa~K01b#7!QmdD zo&>fP@IbYQp|6pKu&&^}%W~+uFw?e%w+8Bw=s~@_CePFWPF%>VnZDvg^KeRbJ>~Y2 zZDVw+-RC_-`YdUhDGxJ;JTJ5360HXKYOLio$>H8nwvpns)zYo$KSUn<8eBKJ8u1aX z$O4k*lIdOFHXqTgt0D&PxnzmIm!yRCXZzW`g7o1iBmrGj$uM=+ zmc#m|jF8k?vg*4tKmdTeG}jGz!b>nu(IJpce;%egj>x(sI8tW~;)kW8NI7aqynl@P zPWMuo5_Nw)Znow5V5NMhdoZAQlelm)rmoz0>@joCPF-qbq#YN}3 z6g}1+H;&p60O{PRCEmAu4v1|?QIvGEXzo!0Kqu$|Zm=agRUCQqv{z|p>2FH|;VSr= zD#`tVV1E9OHSnxCGBT?9Y!dl!ZI8F&SzoUM+oHmC5+p0#ef-W7r0x-2<93~XL-Zq>*GvfNr8m8{CA+jE6*kd&g< z;KY3c<}cIVVn3;4T_*wgzsi%t%;U!DkoW@)ZfDaVweR|itqqRQ_r_EaM6Y=L<4nGFbz!yQR%Os^ zW%I;+IX}{SpS`9F?J>0CII_f_HoVScixzulTfue3sQRtsi|hQd7X5yXWAKF*z@Y#I z`=8GcTu{RR15$v{Mhp^+}fpb1_dB+4_5ae$}A78nNj>Up3wben4Zk zsQ$0}5?V?G@`?nZ7Y!DY6<%Jnc+l2SG(v5fXB8f#+z@S=sszSht}K0fLJsuHflRbR zT${bBx*&r~R?e*zgP}F9&qk3BwSF|wdR~9X{0M!h`Z_pF^2V&*qoy@UD#G*DTwTDN zZ=eI%SOwEZJtkD(3xxP_0Pk_sU4&IX&7q#qgoz=Dz4^qTh;coXImBCBA(JH^HAVu~M}fIR~n9 zLjsVC=%Cz3V59-$B5mqY9vfUu;8XhTd6sur1k>KXkYE%%iu24a~pv4JrpbR`nlzGF7|A*e5;z(57XVGdj@% z@Bn+o$coRJ2-ePz=RbhS79a6E?-uHV7BC%{%}VZQBxoCws!?C)Yv{leElkj`_Wr9p**ydDZo5J% zp#6&2uuvIUqqWdiCQGVuDaw0_wKo@K&_ug_X1 z=A}v{>aM`c&rA)pgrjEfxpisG!$+E0F~1KUzSI5~g_Qdt@0O<>PoOsZ@XCdQ)DHn0Q73xx`Tx*ICNL!|EvT{-s0dWMeb> z3v^jr?*Oo40HLY+2SQV@%Ep)l)lnL_U5Bbj;t7m_$)G_;7r1L7R^J@ozC~jqcLmx@ zgq-y*a&7G5)52fvxAG!h0nLgKtqV zP^S9}b%7Xc(ViCQM4rPgDSd@FzbgunfL3h|E6%7&x)4pd3S7HnWyB#4z&O$P)d*WJT*w@{Or}4?|v!XG#-e7oF)<@b6>~RA=J$ zHH8o5ORGExQz@9M|B9GxU8q+bg~X_RDAeHYH~f`j%=;ek?ZROId%8#wv#*9j|& zL-Dr|Gd&5}wS+r{!tuPCB*Hfg?6>XASH)od#R`kNgEkzWl<=4*OxyujUd)iVH;%0n zU4>txgv9xGjcC=4m>v&ceb6LG8O0a!DwVzcO;fWaJJU(8b-Y-`94l%r8SxIFDjLX@Qaq$Dm+?zjdO<^m8Oqq3AH=a8fMm1aUghg=t3bHXUy=S`_M}NV z=R-s~X|5vo3j$GIp`2o3*u4nzb$?66p`i}?DWxWuJ8-=7-w1+E7 zrA)%^<9kKYkV>Oyss2FyoPoB~&*HzUfb?MN<=`p_BRzr3#zvPkBJ!L%l5rz9V|t-r zpW4Qvd&#*Bw?fxDks4m!6m!anl#993t@jr)B9$TvYauY|D@skPpyMBgjI3 zpLhSZx7Eq}x@R|Ual5(_hH|?_#jA%hx_>c%)F_6EMv5S;%G?^8 zJ5`s6$VE&^y?REBd~?D?*4cRFv#%&UUY+__V9M>ehP48qv)3OCpnuA#uMUs6mxg(E zc!$62pNG%f;M?wYJK_!@}}dT63bEp zWQ1Rl?O7Kw^mrG;<6e*B##Zw_t;)RxVgM@jadiny^{mkAI-M}LavHs}Q?CM)DV?Jn zjEF`;3@=01$Z^&ItxLuJRU#{6zkEe7`=yJXNH!q@|01LP(nY^K*G1d@Qx_d(S}n90 zb^UL_HTXhs9rq8xb%jZA5lgFmK-J@Pd|~`M7>$N-in`|($`P`jaf+r~VTvU^pmXWd zK#{R+z~)J0e91pi8w0C2M@lu$nBA{9I#3HC2albuI##^Hi`bCHhms}O;(j z%Izoc?KJlP520OE7y$P^MR}`SkS)R!s?(dm-8OYko*fd0j=BPvtVE^ zHizFM)k#IOke^MN8bux*F}$|^4|e5-@QUCN(2tDi*t2@1eBgZgRV1z_z}c`%)HlN@ z{##95xak50CgO3L8S(6b&5n=a6`et-GmZSGUxAU=NAQ$jjOpxX`0fJp4jQ`wyqgGo zd|afWl(P_zo?+IIj$34r@E~mzn6q-9%Q<8q2N*o0C*2j+h4)9)>NvUU8-;9_^<}V1 zo#){{5eXRH_8Y+ZNhTV(ngIc@2iqDahFR~n7(cq|f>8r0`i8Py1=t{! zZ6jUSS@q{i!N&&91DaE0?OvL80#nwW$bXpj;bgwy(YKT+e`Lypt^A?Idf1C&Pn3Ip zeeC9vk0?kKrya*T3`lYzYz1s4^7mGY&bs1V!BdNjP1?HU*sQD*OZ$T3_P+V$!^i?S z=Q~G=^6tymz{uAHbm8a&Bcq_=Fp<$z^u)&uf|xRzNR(ptF|LoCY6Hr%uT+IRa{pM=x{aFTg>35aPey7p2HGoSuU0R8(z6Mk8vN_V#)BG< z=`&5|oYd~w|8|^eAI`c}2rUHFYe@D+^@%E#C0?`=x~zn0$CjkVj{`!$qAtp9-L<=z z(^wZSY3;^QC>#6+UkE_7gpY{Fam+4!FL{P$e^&gV->2TON(H!<4huh&7lIEgQRRQw zVO+gTFoi9okdtom1yCj6%<07Rmib-EIV)!JyFbzFJz_a~TuDTPpJaKm?q7H&mq0~8 zA-^CskK5cciY-d~{QI47h#oSOMUvr5%73I@O2i<{|Ds<0qI>=SYh$5SQ)s#P;_&EA zYPE#N#&oP}i`@_~7e+9iWDUf5>R8h$6Ov(8NE+ps8E5+H;ZR%dh6&D)Ze$VTb=AKN zq`RYbJsXqWuTD}|jmHZ5s{TqH9J}6PsYYME(O-n||C1$x{$T?@o6mpWVZXC`{`szC zxg`%wi>|49#&-*KHTsJ&z^atsIcpSvEd?}(xHFU3#FGhnvCmE1HMGeQT-$ei^f!g^ z&5L>VFS-_rS{90zVt;k?v(}o>TpvHJG)~+|2!T>;12vupToh>Qn;{eb&6m_q!;xO& zG+G{c_Hf~VFK{r|H~_6^5n5b4xWlJmjyM$tko}_Ix@UtHqjI>_C_dhZfmQ9gQeHQt zC!zh4Gd{>BWH<^aPo_&n`tP7{^MVCJ3KD4EKm!u*=CT`%lbphP29D^(1M;%T#92AT#Up1kNzRRR$uZ}R z5~R_qAndBUq_Ta@f~;}$o4&N(emgpU`7V0zffS&$bOcAkLmO@6cje-Iyf(t=>dIGe zGUfi}P||N;H+$Q*)qxksPtlt6D#A{dHviJSZ>)Z7G(M=O>0JH3YyF=sfo5fE zi*S^8Z5Xo<|6!e=%u7kRuZTa&aRn+LaGEQo3w?F3#gqoRJY7bf0sT=FNNc69uVko~ z4ZwJ#W3=hz`9|d--7g94y{nbWM6UV|0o?LnDd+q!5h=7k0;98nt9>U;ZxK%Ej`rQM zJ3JM|KQKW+Cz)zaw{TBQFPJrRidU`rNXJO73Tt7Q&4=Hehf)^Uu&HBBjg1ZB{dr3A zmCLC9xK)9K4XR7IP z1!@&@KwWXwJF?K;w<ZS`=pGB%9fc47`>6E4-yY z4{uZc9o}xET!gm_F{vwAotagU3L1{azwg`3%>EXjwnsQJivKpd5^9RZtN(@B?b8tI zr7=v(RDHvbc-EHhS4H+Y4gU&0sPwK4v5Jmx1WR)VRFg=b4 zwy=K}HL6$YQWQp&fud~w)>HHbg-ZbK)*h{?Kgyo$CYfPqQN(kLHn2d>B_~8jK z`<6H;_I%LSQV*kDBZl91pR*ZhaG!?fHygQJnVLELCyE(%AK&!;kk2Nwmu&HoibukY zJc>p@{HDPn=X5hKzRS6)F=tPeA@;{*rwHyld_?A`K&OaWtIx?xmXn6h9f3(yffzhv zxO*Wxh>hMp=}xb+_5u+r(>f+MBqwwF&s$9fZ;KU*5sxf{J>NFv^2IqldI8YgH^B4{ zuq+@Q`_Mzvm<)C6gw>K`HR8UCn$QNq6|@0P;e|0=Y$vnh!M zN9_(hj8C^nbYqZ?VlyY9!AuDe`GV^`kZk2u{xGZOS3-7G(f!>w2u?Jjy~6$fqHmCW z(zE0uqos#M0btX<8s39_2ktvHKu@jdD0*XH3dw@g_#zWJ=DHKC>XaL)#SuNNSUSEa zfyrjE5h>YI6OcT;MbakuO1_5YL`rXYd^&s>Nv>c?sDc{>ZGLrl+x~fIet|IvK`Av; zf86{v#^U?oBICiGVSPE+2Je3gxaE(w_Mw%Ny!MHrgc~D6#C4zRx9?UmZ3ym?&_HyUn5zsl zOy?YKMlg_Iqidn(o!}1M*$H3gNl0;L@5^DTQgVsu4F~7sA5r%ugB=Hn6jJ(23#rt^ zPEX$EAH;RF%$y!`Zu)YcK#6fEv287@`7`yK*x7wI)ymC|U6yn*s?u`$_PH?qn$jQ0 z`^iovDkm_hX@-?&1kJxe$jqU<-`75cgYI+%Sq3 z&!lTgA_`t~z^4>y6n*OJB`B^a&cJb-wJjn4l_4!=T8_fQz;99C9wm5!(UV(nr>%V3 zF?}AJHRnot1%Ku3d9G<%JFN#_WMdER^YOOde;-`ayW+g2y}D59(CN1f3$|Z!-Z5G= zLV0(}+wv8?VPV(eu@-v6%B~inMRSBkh<9!e)R;S2W}HmY*E>WO7sDq!H(c}GU6`#b zHdO}BiU0FA<>BhQ&B_w3c~ng9dj!FUgxD`S{Ckd36Q4Kwa}VC8F=LB0vts6~N(~Q_ zV&A9kJTdMBZr@@pVK#7f`x^PILCd1~hn%hZ80o61IHtCcJKpfXyB$RZE+5XMGWcp`-lRdO?f@c8Q7y01&@ z()joUDtPJg0+e1YB%Tmh0zQ)Dv$EE@C6OO-6i8IkLRdAIXAi!@mf;D|@;?ZxdL7gQ zlc_oktC9{HfC;$!KH{s9dJrghKL;wz+Us&7U*e6ie{DkrCU9@cbYCi$=0c(T@M-(I zRr7`O+MP!ee-j>q*tVxjvr`fyB&{sn+mm+nW(g@q2{9pLNk2;kffD!Bq<% zdKl#@f~!_P44}Vlxif7gzWEjSl{(?BbZikicH(kt+6A1U!e6OKy`hY)V%XBa`dkhI zPWN`{1K|||B?l|zGlNfN9p;^Es@nEDc2^v{VG(P?+s~ogXnfv<4qa`>xYgFKTO#fQ z2BpLp#*ujo-+bnWt^Cw>^A|ZpbWYWm8R?LTwqez*!8)KZ8a_ekj%Iz8Bg3^ilt@|~ z62*tPrNd6;z-yOz*;wgR-Wt1O=9rd84o1~Uxy>F7W-C*2@{SJ=02l93>ra>lF)2s~ zl>~x1Q-;RG`2;WasUfU7Y(aU`gu%w>9rM0PaAaf36Yu>!6Q3H(`5KdpQ`G-Hr97;# zNyKb>+lVwMDEPr!%ni;uOuQFP{)TVzaHp+(jgcJ7qsK-*GytPs zWItkRl~2f#EMH{Jky(>cWj(ur|5O5N_# z?|QP2|7vpMkh_z7)uBoZBs{YHCV<7S(3lOQt$-F4g9i1N1zjRUhwsaUx`KG^ z8S^_iR~!za5Vl0%q7`}zA@kpCs`{xUs8&IJMUK0haDI$e73!-#Ui`pCS*Zh9JPMbS zPz{j{A*$KVF#pb*y+p|c%X5+uT*+l;zs+5(kEbtNK?BhiTY`BN)M=e7WFNGT?LEL& zxQrSrcGSfK&JMGS;fzs}vfz>7sZgJ@gXPy3Zx3x7>5CKgs`h5vmnGUKs?l%1>U&k8 zXGNHauKqr4CbLSgAfQ#WSuoN&vv^&0-k0N~+0L(-M6!iZl{C+^3+@|(KOtVzwxzdk zFRH^=)3%w@5w)h!NvM!Awgpl!G=N|wG5>pywQVmU@(c%8qZW)*+l)^Ie3t?#jIeU& zu%rO1lr$7IghXYJJN1_L4R0STKeA8>Ag`EzN64MDp9m~{WG{^T)U!> z&j0lAUFOc=`tC+#4)h4`lcft9lflilednzhbDw91HE3|?jNX@zYV+aJ}K zORt_6r3_=Ac!iz?VHYE85}qwjxqjpff~`fQ2>A)b)F9%q+?YG!6IsD_%XcBp${Wj4 z&0U^@JbUa|;_xFIPqjYVFvbv)k<-VD4O|8IiCv7RMHMMSOE=YPq~PN<$lO+b0_y*| z%u##WtqOIQdzksB`Tx~*z&qNg73$0XaRVf)LoRDV~pZHYo}KHcrH3=oX^2KCrqwJ7ka zQKPSroI6Ed_ACRof~^P~xb9M5a-dD;JXh3pMPONjR@!-Lf5g{moU~ToL=XV|)PZMlWWy?QKw;`1#Mi4B% zu)S#e7&ZD09xI-Tm}$FYJDaNRjhMNn;WiE6armaa0EvyT(*JdZ#456}Y=}mR{piGd zV+cXE0GOru?9H||^kVj9bE68kerd@pffZ*k=6&(JB4Qf7vb2`cqaBlyzndw9zVg*Mp+asq^+I;Pg zNa|0E52Rw{#nLf;TZXg?%TUvax+`6HB&rE-Skv1V3}vsUzi$WMTXc6#9;lGe4{h;X zzNMS2q2*9;B%8z-tD(CO)q}#|y8Bo?^Iqefn?5w=?i!EQ=QsN9or-6i<}Y?Uh_I*< z?bxCgHxG?XXPJj*(43C0l&i~Bj}#|HkyoC%)kjuB1gAPd-)W}b5+vZyoAi~DGc8Oc znf-O2lHJ*}hbHT>ngs@S{;z#5{$2cXpYud0j%;r(v-re{)2@Pku>Opg54Wj0;EK=y zX^*gaEWdLxq)!DE>qQNX)6}$V>g}bKh;+>0;GL8Vj5}tUj%Y#JQwYBrgRDljmzJZf zK;~!vz9rEuH-w01k2_{(sd=mA>^8JK>?B?V1@eQqfp==lVqIuV1o7f_&lvy{>Wpl- z5~KFHpwZC2=*P1Mb|ope6xiJc_gbbUyJ5kqyF;+YI#%=*$(6U^wF&*E4VArs%}?S? zQlqyPl@YC&e;?gJIb}m3kGg)q8$M}y{MeUAy#^epKelno`>la??d=ht8h4qBfF`6p zd+I5xJjR)8n)=f}Q$j`8&h|_jwJDpg%MtM5?WYUO(1K;EYW;G32*JDqnpzb|VHA?heT4oW{3Gxq z3T=ac_hroBHdmV^4Qa51^;}8YQPt*Vt3wZ>L8Kr@K(|)8p9FnVQpG*W;Yi zLtuK->E2Ah=|=M|?9{C0wBqChc2enbGI_Wk3|k1Oj^(eY;@dhJUfnMkh3i8Wz}Y#j z`$xmu`vr$^{oMudT29X4alz>U_;f!O7(=xWgFsuq2)Kxi!ZBQros#E|Am+l($F2+9 z7JP8;Jy_KwooT;{^%36wT`o_zEoKI=RJzk5((FETm;a>a#Ii`PS*q*Mw{oHJok;AdXYg~Evf(@J-*UeUB}i<1GsaUu3Rn7!J_Bm&`AD#7AWE__wu*4Q zK(L+b{tZTh$sf1&5~zD}bGUCfX&ZmN|Ha?orW;;zQL98hnSDk>h~HWnL2w=lez|5w zMN5^Rk@Rt)t=!0yEqS_OBkLHc9~~sVxH!nd6L@VrS*cQ>2O^99H(AM%d^NqHsTM~+ z?li@F;qd#6NeJmm7(_n`=;w9Bf4y6l`t-?@N4v_1&*~%EEW!leqC#@IkGDu!6r_XU zStA->I=f~r@99~soef@*Dp44CsSp)XC}-t?*+En1X%YAC8`q1N6f9P08Ism}&SlHa z-!;dWClQ1guq7(@hIQqb+KlU8`N8*5f9kV9AIhPJAh#5;-RSN}%x8Hu20KIuD^uoI zg)@h>uf^A#aQBoKmhIEqQiN+p!cBJuu-LhJrh!O<(GyC-C0H z$oIdL@JgIjZdZjN+=6qaZ)@Jv>1ptZRbwMh*xJP{YF`*C7@XMIO?VnFeZ6cz=o%yHWC%mR^3Lp2QQ;{nZ(rU>xhhX)jJ zEOVLhn-cjuD9>9JMfk$Q)SXD_(j{#7%_9z9ve)BqI1CrtCYW0s4K#N;R;!cZ$R%B^ zdB$a{(u(RH1XRiG%G)5&zutv`riZQ7P?~JXVkze|*m5=UpLrZ*i zkA>;Kyc^BeG4|Wtx7B$}C_>*M#oaCFM6UTHZ|lLJm*3|Udrln)5@BuznHEar>Qk}d z>5I2|cx}RJOBHt^DUJO|i2SY{0q?g-XO|H-$$9GQ1rJcns`o#AODVE%Y#vq%%DpvV z6P9GMaq*a(uR%B*9Jo`+BrqS3*quK8Hpz8%-Zb^~dOR^wX&F1^UEOo!hWon&UG<&^Hy$#D#RsKuIUUzOagkB2U(X41KRU2~_5FPeXb!5*xMTjY zs|q`cjBf^O??7ZeSe@~<+kMR3$tG9EA2%(h1*Ih`6(w(4YWq)-E;J|vD7$H6mmW$b zs1Y*UjPL%@Xmz9(@bhHb)|k9TyTTGG6Ppq6V-L&Pb4mA8v(=kx1g#Ze1UCcALq6R1 z6hJ^D`Y=K>y&=*?{t(lMsqG1~30xH1rgnF2Jw>_sy_ zL_=0P=iMJ3e0e$o=ct%mEBvlk)Z*aXl?t9!HkpUO0`WMZ zKW`QOxV`x$CPl({Px<)s;tmh;6FW4aEac2;*f(jUcNLvlNU-V1CA=Ba%~ zu+mmpbH1>)q#9U_!EYnDZZ}49(x4U2*sT{s#JLthofQg=9z%g`r_MQTGv3l6OW7|D zohd)&jj~*LmhH#3wUw@Vh}@XpAGyL2;bEVS+%Wp7zjn56e(dPj$mz@TCy=xa#5nhe zy!v<}Z61%fR*UU-ZeL2oH!=dNwq?i-%vQt`4At5`G1Vp5TarSXmBJhrV>)mGP2fF- znZ^_k@7{R)MDqtyL#?GohB#gLXTEFxZx_ljMET7m`?@&^Xj5TyOUo5LK`jTGJqpl3 z=EC^u0`iTTxREs``Oz%CWKG}M#F&ivJ=|Shb$rU50j1F``0dB}q1QC;yo~#VLW!xv z?(3A)?NF87A*Qq(y;=z6CDFsGEBmOd9j-bQr9nOMmh~<4$%)l$e7R4M?dRyeqw#iNXc{K;Kyh6=g0k_$g(kg zQ}dMkt1hpBhQgAoLT$|LerLM=?eIpME#rV|_+7I86*MGPr7mCAQi$Ug9hPU)b-wSg zYZbsR4GLYnEfg{06m;_bjpPqZ>mI*kx=pAsch0LH9gc1+oNSmeBT;%FjB>Ax4hSxy z?#q;>4TQ({Kiwueq6yj;^As_T{aA;T;k+Z$ zLs#2&ncCtAlH_xx4)dlmilsJPmATE@qHsgc1x~ z%FQ^wnlvE0je?HxL|OiY#27`L0ogSFmsmmqSV{d-*Pi;Z0CNaF3_C!l*OkI>q$g_m z$6Z~8=!}|(FAb2OLtn+lu|;Lqrfcv#5pRkvGarwDf6j`qlM8BgO
ySdvZ8C2ikE}>8*K?~2_U{VFB6!(eROx^=mdL*(4p8oF=)Fb%6AzTtls?h7 z&Hm=PKsbV)vedz$B$(PSxLqN1&yZp-lRmwn6V0ahHveq(ClrAF_!pFot%^My9b42f zZrNm5G@oU8X^_=8d+!~2p|%MKYv|RW8+aG9ez!oCGzVCObgO8OuWB0Vb|bV7&4 z8_$n>zxlRwuE`p=+c73Vwy5}U&M(kKh3u2kC5wg86AZH#Uhe{~H3(S>E=EQ7qAiy1 zqy^NTr8$3qW{T|aA+k3qpj|_!Bk6m>V{CA2|8ScI$qGHBd9<{u;f%sI+{q;M-;ZsX z4^~+xD>WrnX`Ryu?T|eB9jOWZj?~PIE!C_CWSEmt?>l2shg^{|E-xkBvPIr3#<-mH zIna|<+{R4Osi63#4%Q|=w_R0BvGLq%GNU@6_GV~4=K-OEPY>Qc^u`+Ixx5Ok4m4oSlpB~#4L{DuYzK3BS1K6wUezZe^BYDuUnhru(mBW3tk)>hN! z9!RiyZ64iWbqcz{x_nBottu+`+>4ANMZ!pyn-V9WR2vL6=M`{>s(SB=%WOUkAM*=B zQ}XVX%!23InGwut$!F-Y`+7*h)5W)60O1GhZf8H)7jCv^COW8LP-?#zfG}y)kbiQ= zwJs|8nMW=?X5C15Qn=G2D|lQ`0B<00y_t_@qJA3=)vXC7%pz5|pL8Z#I2hWWP&)IP ztGaWS%Ci*bbo4-~f9TOT@)<9&;W&k0Kc03cdN2PlH)+odP4EXDwfhFD-`o{m@u3B_ zQ%9tn^F)zL2o210x4JG#dGFf#;q0bY7=fWmwaP`ZGJ8s}co|<{w7-roC%7u^^V*H` z$zQbQc{S9n&JUUq>Ux}g?IKvmtR#srqYvBsyq4urcea!YddIc%-S+@Ak4+a1t2ah` z^}$^4O zkUNK`l>PnXZ%*FQ0KCTGvpZ6u)zO`ieus%>WgpULx28FE)68$@eec?JK;yM@+TRD2 zMClz&G2e-3O^MHPzM$YAw;u7n$I(c#pPgB}X_Gq{Q0fzszm&ReXeQ&ET+zdmhLdNH z(}W7civ1Ghe?~l#C-g-+9OxcXpQB+>%Ur!LEqCZr@aatt4UH>$Lzvi+S6N=&^j<@) z?$bSaDhyq|tNldowqa=5gxFA~r-7XV^Wx7(*S8#g(!#WFrpk%UR7yKw2<1)~v5(hV zI5B4`?K}5Ss(t5P8gTB{sj%ark~(myvr$Lu2ke-M@KC0CnoUMOk4QL>zo;k5Uu5rm zr7Ew4SUT*Q5+qzsmf`f0kYrwc=t)L>Zqsk4!V|CY_I(SJGrRYIQ-tOH4We zYKEE5fe_IiJ_W}vw|7XvxS;wqNwEH_6^4aRk}(fos@vJGlU*fQ?pUhm zBgLlh^z;2E1ct*?1&zBC-$+B&Z5bO-G7qI!wZc^x7KNwse?zWD1P7<{y>C{Ue(W@9 z@28HtT7t6CQ011S=zJFXWb4#>9vhkFvG3dQJ<_Rn7ajhVo7r@u;e&5wch97~Lg2OZ z!qm<;?-QK+lS5t_BsHR2=1qTv1U3@$spG0(VZi)SWqfqYVrD%U(bOh==-5qDzg_d@ zM^idk&K+9Brm*k|_sH5k?|%O+{_V+pcOP<%vpk!W0M^a4ku3c-(ma1qNKc0d+Uoj9 zhbiCOT-ZVDqPkmYycP3lmwUgw=6fzq-gNzA;5F7_%LAIaP|11opqdW9#FB#dyto`1 z=Ru-uN`LkY?diEQY4_E$Bb7bSJ86eGfOPkHHf;96vwZQ|_uHizBU2trCeV+>#V!4l z=pby0;M)<*!iK?Koak@GRvfnaCtd{z@zM8`JS%Cx#%hNMC1-?Wl-7?_kF9FCWnHd5 zCu1Ag`jLc9#v*H0c9s)(o+PTKn~2rTV3v-^GudY^9qPi;JbQ~-bMCL)N5NV}LnFVI z22uCgGE362%SAK=n)w743?L;FAAsJit-9bKj)>4)zuaT?_$t|=>jio=j6NOiH(O@K z(s_*vXVcHZyM!Nz(ww777UtB+Dcn;74*L1$6l4c-c(CxbAX$bBV2|twqzC4XVbU5g zrkSd=YJUoaZAG#l{AKxam6`+);S(_`4Ac3}fz`hg#4W$A)bvsjb6 zJ!AOMda0=95Fc{Q!laYJacWjU%++n}&X2bfR5#EO?vqkSpNB~u#!7NN?{(Az&Z=^jD25uWolLWr*(1R4?3#}0Ii`BC1C&~6 zcI6wm7N0b^ar5PNA?75z26uPKOSHbbhQz|Zmke1ELNh4Bxd7JRP4HPaJ=)lp$pd{t zu?heuE83go^ck2OEGASmsd9K0#RQPIV>v`>Dlv}^0{?eE5)N>kw(Ke20c560`qfpN)1E;~-|^^QszHd{7lLXV4ffu8j38wu;|CzZywt$SeY^ohEDK-s^#T%`8d2v5I@ z%D{Xqsz&w<05^fs6QJo;;Lw#(aIccysm-3{L2NQ(HH3U1C*on;M}b4!ns5B?NFY&! zw;5F%gYjym)2CK-%E5{%h>g__(k(RBJIQWN`<%>r0609?T<{`5NAt4V@e6zj&IE~7 z4x~Z5)Yi1vOwhM|IaeLbQ=g@iQ!gtUw+o$J3vZ`{o3YhAtvzypAP!zMX`lNv8M?O; zF(+Sw1NgcO-`8#lZ+jO;Q`xL?78wN*>LByiicl%D-eRr7UfK;L>Thd-0o7zki3fdF=lyV`fua9JSP^k&DiR$)fd8<%Bz zX?KIniXR`KR`gWqRycw;-^w6;%V_BoLF@KOAv(o7k#fG~KKiv{{<3pFIP{jxX>UM9 zh%rY4okt|Ce2lLB$e}0;C>(ZtD(KQ`)$m<&IgV8z_!ygvNc)FlR@sQ{SQ&Y zSP;jjMV|g!XcBZYqJYE-)>n8oRru^}+P0_AOxLEM>C=eRfjjgcOB$IWI~}iJLvX3J zLIk3X@=5%}iNT)0w#V!KtS*SqHm2e}V?RhDSyVoqzT}A$$KSsa-nPd+X?e>%(f19ES}hslWjyM9x%$!4 zkr1(s8>}*nmspv1AGS`cT$3Sn3xKpbtR8?JkQ$PNa#KX;DCbK%0iQYS@ zt^qNfZgE?<_fuP)g*wtFTR4j&J&t~%W%748RbmN!;BE~%d+)}hwxz7?^2Y~FsLzjw zHwAKdLvIfl!D+DtrHt}S=nut$-^gHfT)MJ4+00y%o!F!*O&7p+A*+&K6yI+@QoF-E zUZi{EU|m5Hw2Rk0_zPN?T&jUb9!RAw#b%5iI3Ktb^Co}-2VZi7lUwFTnTBuDHCPl= z9C~gFu_e4Pm{@Z^@o7q$T{IBgJ=3*(O!GFIslbbqJn{EwK00b$WxX5u)gXD*wq{pP zLRwI{$$FQPM?I{c?CyYZ=vAHQ&kC^*+p1D$GzZRn()9K5Ag?32c4}EbmiEk6@|X)? zMLdnO7qV=`Kb@iygK&!>$!%VHWE&tP+fJHOV1g@K`WVXNx0`8Qh-Ag7dUVV$G9Ny+n%5 z9zVkur+q(&LtX#lnjLxEPh?z^M9o!xq(Yg&j3!yd~rrVTA-t4`gvA{81LILm;#TZ1rK zviejo))EMYSMaGGYkiy6n3f4ITd;E+GX7DEDJ~9||9~SB;Po}yDcx(z?S<8Vg0(%T zi@dchmYF|gX&t52ylK9ZaqtmW=4nld%WfY>GJ6vg^;uz)M?LbuP2X7+RPv}NpxCO= z*UnXPF+~~zl2br#n@#Im7Q(&zo*Iw)>D<+o9HXk`OFsXkO|%xpLtb9r&XQ?jjtv$Z z>@lRtbkrJlc#|2SwZ?6bJf+|0TCYLw@CwPs*)E+uP&7nU|4{B#%shwWn&fYmQpKMI!4mXlV_@xjYx9o_ARwV~{?UoGTZXsM5ubt^|asz9iQ?n<>n3 zH=?agngPRZBJGiF%jvp#|Eu%W_bBdn%j0e@iYt`TW$s!x&X3~V*@GTa?|wmO-_J~J z+~Vba4>?@SBOt$$#S$qMnA;kNuNe!s-p;GDnv^36PZwiHCK4MK}0;he7^HYzXg(oH@B?S`X~4$lN3dd(MH907+on_ z)r$K?7AT2LV(8+{jybKa!dIfjxu0h!11;rP=ByRuCd2x$Y`T;;asZ@TXF`T%gA3rm zR0*cMxU^zTHqC1gr9}~=G|lAoi!#R1i2U3Z8#Z6^D<9;N0sdlpi$~q1)rL6t6!uku zuV9M&i7b%T5|gJOBBL3OXjob_J}oyMS^l2m28eYzrnjqjvlGq`kKyWqRopEpT5*gf zp3aL&XF*KvC8aL~xw-#;W)wIDiozeeJ}n=uxgI4?gpw{gz8o6@GG^d+^uOIT0=nY= z1W(eZs}#(rW8i&}RAgp&z6U0^;Cx{pNS)c(PeLi71VL_*89?@r^XDD_0A#^%^n6wNdOHe59X*b$<=k;LqXS!+r3d&dvS6I&7MZ!M?ns=s7F z+9tbIwTQyh>Wx{_w;6Y)r1+h5iAV);M%KX<4XQT(1m%*?H_vQ*s}5rT~*9ao(ux$Y{{yPPPwH99FGFf6SFc5|$j=}EyjegL&M?c{FoqljP zsC0MN$Yu>}%sQT83UXPJCZaW<1m|4o5_tu~l*hIoH5$R?jqi}P2}-!USybv` zw8T(53-HG39N-7v{9uiN*QhbtUZSIy0scvxt=midi9+4P|HL2rzm z|6lXR|3#W>bjz}` zr@0PxcWblAz@{}y9sP~p97lNvOMQ!@rIvpYNPhkfB3(t(B2GqECI*@<;Hy{9(*%A9+IcJ9z*&9IS3F4XM`8p7C?N3et_a3Jp(u>CY_L@1Rz22lr zc?Q#>-pw=Otk>w$PK zIn6vwkhBT|jH{|-DdGe@08;-u zL9e`AQep>7F}Dsh1r|XhPW$ z`6CMLUP%|np8w*>)$09?&<0Sabj5{U4-?tQ#kC-;wZ+u8D+AV+PTv_-JER1Og0pl> zD{mfKdv%t=3QNE|eqHG@3xA;uu$+-jbV8+u2#OeLL zG?B_e3=3hvasgq_ZyyYB7;HI$09Kk{#2$GBuaf9Z-_9xM@J$Uy902ile zIvPmM!)=43P+m2J#a)Yu?UAPNb)Ia~d@pnn5A6k|D_-=O&y`}bc7SMGprT3+Wv4Qs zb5Jy)_x>*o51t2N$N*jqcaVw67`m!M{CC3Y3`Ueg7S7#IV}AChP*qpcdMo+eH(q?p zk--GKcN!(^##9&QXY&Ua&i2vj=)#g=%hRQ*F=AR5p30wB5n;4@#Gtm?*l(50U74EH8umuv=Pd1)plfnGrs>Yo)fQCyzG$y7}&D z*5Ry-4N0jJ{pyj=r9PVsM{~4MV4|hoBN5y$UYRrKAvI_DOHI|1{P;m4UN>xSNxJ&1 z9sbE-0oa|*z1gmX;%1Ox#vq)b%lwd&T6Kx{RUL48fFS9P>8hVcOqABkk#lCUzx+ap zeZTPNZ^B*Lx#B(arx>FnJjp|yp2Tpic=xKzQL*752#ws?Pjvan)jo&6r(EH%R`dzw_o7?X=jnkYx1LqstmaQZlV-Zc2AB>}A{+KaYkJJfYmWiy) zQvaEndQ9&|dnjuRVwht3S?tV-!*@IS)7Sn4EEd7{gUMut2g~ed6m!z(-R^;tW??`D zWNrRspB2NOGg*E+XHpyL!8TFg(${Y5m`a83G0-gi-6jvSHfm3KKU|?tI9Zz4pJ?pU zw=Z~4w**;K#`vR-Ph2@7j*riv8Zz93ke9TpVqs1w1EE15!^bJeMdFO|1NntPWj`q| ze2a}d`Z{#7?Y_O8Uh3l77y&hV1{tgRkjr&RDN@<*u%OX=j{JU+FB+W(ShL;g20$r; z`XSW5%-+CKf{V=d)l%Wv5-XeF$wHBVh>Csihl5OQ0naWgxkC4|^&w(w_uL~RK?iMY z>kb(+ofaI~N!OGfTY=fxBx2I;pVo8T%zD*52nN>T0VIZan;)9g@q@%(T6TPtNDVz7 zmv8DAsYFbeY@a#N)0BAZ@kBd=V6ncl*LR*`x{i*W|36$Wkt@Uh{(?yq^xw5$(hdF7 z1#@Y$1+%sUw}e&&w(TzpnY;%&5GnK%w(BmUztjzAcG%1pwR~q%5W9zdntvRhRViR1 zWL1(*pW{0ZeD@2U^A(WOh)+zAFflAZu%0GEQv7#p^b-8t^a+8QI8uE zjvttIi}D@X^2@=Rg%Qs!XwTWI4IHd2-4h3|AN3(f2%<|N*!h~%%U%xM23w#+fM7Wx z5m4FmTLTh^WJ^>TWR_HbUp{G5)GIBm_J!ACi)Y>`yVMucYN>}Dw z1F-~VvHjOyFgima8BKM3EP-t;me5oCM=Sv=+Mz6~(ZKilqyj5CVxE?6i9V%TFMPDy z(m&OAcR_pc;+tRbGv?L!S%@e_7jnt}OI4xiO_1PX#$L|-$b518n@ct~Zd`KN!as!- zwGsUeL<9x|zorVuoyl6Sc)?vfH=>-j@Mm>onEcOS3N9ARR zUFE}5lDB?{iJe&(UYZO>82TipI!NTHKAvPSSr_v}kp?9>=?+^Az6jA1JBd_0J~Y-^Z`U(Yvsvo=<#>|1=L+p2dG_TSlr| ztL>X)zYkJX_X!@-Gp#R6aIN{Jrc_Ck;|ig#6zwJz%k}<^Aj#L38 zk{nvCRPa?M7ZZPJD>wOI(@gW?Z4$l6X7lnFy-N(1Fjul!Vwn)Hy%l7j8I)Q7?nV_k zAep#zgKldc>4}$#+u^dnTytHMXV?v3cpezbZD7;>uxpA_e0{#}fM{}`uZMgpGBO_wXO2 z0DO?F-#>`YW*@|NKX&2~8I!#`_bjnwBhwNcK;mF%uU_brU_H8jpO~vyZb9W>_qWO% z+hO-d1c63X0;6P5k_bMR0QQ=#5jX2Iq$WI^oZ*I)_BO6+c=%AVDJ1>Ubvf&nBR`20 zMr6;$!&h1;njB$P?XfbPW~L{2Fbjmi)O95eEpacOlw%{v4@>1y-xW;UtA*g2@c*}w zv|3-sd#+^NX=AWVoWVS?0H(t5v8zolT?b?(ItoIr-;N6~g2y6tC|Q^#!# zzgH}HHzl_en6`QEdduQl;CiQ!MXJg6erVM}Wt9(xXCuZrpV8GmgvlG)Elh5*v1PM@ zOx3am{+#fKugp)*(s_kw?;m#JBVFJl$>K6f?x^qTaxN@8Den>Qn4s9R{D__7xx*U; znO(FDz%2QQ25~#j#{5V#S5ABfX&{YQc(zY>F7WB?qzvJ2-k&2({ca>XbVW++AoBb~ zTJyE6yxClX!KCT&s*SFg!K|+QX|G5| znE6!2+)X`}t&GR-RJA(%2Ml5bF}XHjKB!iW0_o@sj=Y+~I75{xQ^;xMkI^8ya6USo zW7f&K^eQm>d<146;N2j21C^$RE^(WlKofyEe*QOAn*9C1`TixLy_xUri((I{E9^(@ zXbMEW_wJI2jm&W1z28DU2)CStO2lycCcEF93Vg1bkuVkRnKAOFV$RPN;dNDGvC>9x z?xyEB$CT^5#rLfC*UO!N6XgBy!S@`TJL^;McDLQq_?<5~H{J&;=4yVsmo z9+it>nP7b|%VcYQET@s>WwC-7^Al=hH_cLx&CMuNi_o$Iz$FxZzQX+0+hRZ^sXNN* z2&f_hpCy3Nq^claZ+=m`DxjEaq{ln+K!=DiVR`U~R2m;l(Ew(cqS@lv7-By+yw%3p z4M3wZ5f?6%CNwey>OX2(P%yl7tz&qJpyLLdn|ms3hsf{P<R$BOLT@q zp6{I8J~L$wGa}VuzZ>iMNJreMd=(c}Z*GA@*J=(skMrTeAc_-svDd-?ti-z_v?s=p z4-b^HOPUT5_Q-wBY;|C^^HBx8VDe}c<>~C0ahJtYXW$-J@xR z7ntzLpCcMkSBDP2!qG1LIJNx2eU=e-T5%=8yGgM0JvQ6Nbi%}9n2Ns6Z%KK5L#z2F z;bHTsIOQxYEg6*^A5z$EUj2N-vNL)x zN?vBz)J*EO!6)i|PY^8Szo}(X(4iL=vcz>-^p**DpJe)S{fv=B7BAj>z$gE%lXP{{ zeSIYQCPkyh(K2vW2KVCx>B~dM*CUK6Q+07@bxOsTQzl=8W)*3s;;?)>L(|@Ne%gBB zYi#89*U0*|2Oc@L{jRKfIKUS`>`Y0&$B`4yB{N^61N(avE!Q|C$g4Id&rRksh;2-= z3S4&X#h|#8B0218hQ0 z->aJ7*TK_p(;M*L60qpDu@?-%vd_Q2ip0pn#)F$@j&p~(A>>Ey04K;xmfyg`MEFd* zWcw9OEIeEZehda6b^R_K2h0x2|ATCr{xsrbi)kz;D+@OAbG$mtHg$}<*9FSx88W%R z^ljTJXoE@rZG)MZU<13UX5WB5PxOY>UAv2^&}vFBm<}n6joP4h2$Ay`aXk~6ELm5| zQHhqpTQSbIWT@-2zeUg{L>-3g8_m;_cXuJj=$8y}@n&vo7KWLHT>W(6*v64sPv=S* zXT)H+r>UxYRGsqcyZs`}0#E|U;-n6UAgx_s+C!a_->R0|dF-)Cs$tVBiVuU--R9%< z6xg_B;+s;ozx0P+Yd0D13r2IiM>evI=H%2QTX;Lh%eD`2wef1EE{bwWp{ znYrB9c!|K^crQ%M-b7^`#6aa8K#+nvxh<*9p~&mlVlNcJ632&Y1ITg<1VUPE4r^EV zlTV(-2G7*X9@>4Ha6s1j5hk(^n)uO}AcF%d|Hbt_qTVffzH{qO8qW)Tu}q$4ccTm) zmjY(}67%CV$I*Ga>^AO|hWJZ6>%7-*d+6jj%_ge6x9H4;hsoPLPASa3bUvwWV)@d} z(q8In=fcOuRaIhaTzft_r=v^$!pZN={T>6n(O{M3ekJsY*Dh#zdg)&7gSsX%m4aex zbZp#ny0-Mxijm`OBu4F#Z>O9A&*0ZoH`G1Yf?UnyZ0egavQ#MOC5{j93XkR1mgg*t zmHJW)9?rNV?PIMd_+7R-tveq!z?V&v04x#iAp%W-E=Uz_)N^9f?-UC111_H{j>-pO=cBT8oI zh`TL`UDeq4d$#FPVm|8^om}l)uDJ{NQ!qJL-UY7fLx4VJb**JcC~be9f3tidqix5~ zF>#CJ`!~u4G-+b@SccY~GM&jXJX`!E{w1CC6V8!?zf3hz-*XL~O;0U5vgP1T$lmu5 zQJ5WY7Ak6JMb{c@>c=UPSrSL41$`znRRa9s?b8fT^|zY8sZc*qeIq?w>ZJ8e(G|fl z4Gqb5rfJxDF=w(X2zX2;Y(?t|l;nh?PDGwgrk{{p&ug`7Sv@$Lk@`SRgeMP1mB@*& zki60d-AD>wfrpUaOSCH~@~AQTnJ>aZ$oLuG<&85wJN%5V^S2qFoP;|C{{EEq!9kd6 zKdHzr$w6GrFzLSb>jJQce@C^~Eu(y3vWa7b42+7OW&vgeVN|RcFPm#AR|Jw*v(PsI zg+W(QN#>F2d(i-|vCIqqA`0A7XS^ibCdo6KgmnAMCk}DaCJJJG+?V(3X0YJHZ6X;G zcw)tZ&t}RQbg#gvzYYYj*?s00o?>tdF!&eY_B>+bj1w8r%1$PDbL<)N^tBnhPfi=t z2PXq441K)sLaK}(eRhQ|%tzhKXsb45@+pucLRwNOnK+G0H@U5d?51q&Z_*5O!!XBc zAE9V0Gd%5#1*?j19ntik}T1~c6M--$QxWh6St@XGGE z#i+s-lkF5Lj^!(-23;BZmVRQ114{rGXp+mLuHe30jMuMVu|R|07yQcP2epC3RX=6R6+DFq zeU|ZkaqhJikZgXxKGMv%?$f7_f>{Jc$#eC6*uX?{e@c%t+^b>UnS8tl)qPYIBTFTC zI14x{Ud(zygQ4D4yp`~nr)62p@V&=;*s}z|pBJyyxNX#Gmhf}P?BC{)vB!ISyX^SUZW8?MFJhvuarexS zpX~9Zf`-RB^Qe@g_XyMu28*iA@EZTd&Q`Qdh4FUWNW%P#dDD#Ez}KwJErBd}OCawC zOW@{be#dBr$?sy;ah-~5u#_4NC`tYcO<_FNr)bg=xv=_I!$ac!JDq`r^&#+i?f(v6 z;1GpgwQWOxD$67J_GH!s7Wv7q`oB$-N%a|X@fZrEzy_m-_(8A$yPqZ~H|bZmX1wBh z2H=jXGklLDT|I+>@xOU7+s!t6*!_+_9#%n=g+B-xJ3%PPU$D8!8wSw2?+Rb{McxNM z<~|!scf*b5K7Mkv7GmLRHkHiQncLxqfxCYem_3Sc$H<3f;+~5Xo?UuGehM(;fZuoVlE7-kh z|NVCy^p?Cg=_DE7CA-J|KYp{W5CzGQT78vs;-g$w?#N~l)JEj+)BKU@fUYdzH(kFy zaYhYTApVVoQtX~>oJ1A+Y5$?Uv~Qx(Xo(fC0#}Cf1SDq<%cMI5_tENlvc9$aTP|q4 zb57@X=bZb0=A5H`EEz*z`nEgWZ2Rgge`|5Odlp;PhLa$~4m}1b{0eV2>=2Q6@Cv{B zMuq>Tx60=crhA`R*dUvE-9)hV)yxpsw&C+1ZX2(5_zgTJEYx zxRyd0eumo=k@jz#;jFfzch*7U_P`^r;AdpyW{aJ=%WMn+cfQvBrUKb~h|%)fo{G7% zW1T+^f^Wz>vS34SCxL}4@2PR|&_UoRtvv{XNB_mSGruH91gE$@un&IzYhYgzu__yE z#mfdkzsUw!qojX_jSs0< z_bV}mITybrNC=TkQ;34BQhTGZcG7czEi6hxOYm#8Dt?uc2lwtG_Dvb0<0f#rWu)R~ z!R@Adp`_IZC~5V}G-4SaXV}>r9ZYZ?r(aKd%2#?8x+xTdpn&B!@Ge?n>++&n)e+I$ zTlUY9yGiFm%7P1yTJVZe+qBEg^V>s0+bZ$!*Qqr}lsa#?0FZPa-35SSnf}O7=dUcQ zfMZTP;P~iTK&9i4fXY-Sz+SqzSrNA!tLpFI7gG-lR`;=tYgiJN@tV2SYaZ~P>32X{ z1Id^66jfOZ!OW8`j!swmJDq%Qzi?WG1ViM@djo;Q}xNxeeCF}I!IS`J#R2{e-Q-KdWo;hp+g=h2Zms8L+`+UsCqGtCP zSVE&PYARMtJf)=%wPM+J6dVSu3vOH!B zaNH5W9Cw2AhmQgtji~6`z>oPZjVx<)w_OW5MD|m%-e6AizOulH?*!~bEN&wr8tpAU z{^HC|xo`MS^XTZ;JBsby#*fIQ9;h4}ejXrLy*{FBXU$2p5NmJFG++jRMahO6RfPF* zr9MD=n02aQA3p$=i4soh2XJxHyff{1&p=^E+p>S~PqmS$1v0-=xdkj947(^p0bEv> zKd6OlMqXl2CSk&|ux9ZGj06)7r8RIH?gmEr-{LLP!f;t&MW{{4h`Q1WD4$5*g?>(c zxKjd{SK4^~L-UIJ-(Hn8p)|hlD68fn{n9AkRLzZ3{WzB(2AU^ z^w~rc9y{@GH-1+IeUN47g9!ZoK{j*YV3PZkku|*_Z$Hqb7QGPm2OPt3_HOGUu+3z6 zbb1n!M2i?5+p4&Oke6jpIa+448q# z)!n0om?t&xY+>Mw4&w3CY|{uG!EMpdspR7YV*5%)D`XaSl&hrsqV_4wjYIy^g^jj_-oo zHx>Jw;Yq}K`?bkbTe~pNT+0qj-SpUHT4<0oJ2$^LB3 zX78M5^?i}In9WmQ25CKo2MRPWp@{fjd^$7cJTP=y{yk5QwY5j=&~y39#owU z4{Q<)?3E_Q_?g>Y?7BF-9EOe8$gukO<}60ysQZ`6_E39Y?%io*GE;MqpN0SUy!5rV z2gOnV$ON>A9m}Vm14VMC^Uda5!7Gm}y)wfYa`(+X570JP_qNTBns9X4`0OoUwVy-I z*)<;a0>wJhQmnuRGf9#m5mi2yw&0NRnp8;)6L-ZqATM}b$2F(g$@I7^q0CpfFj?_U zA!MR)xT*%xQ(m11@4td6P}wFiEu~BMU1n=LVS5m;92?+inr${Jo2E2r=2Aqo0?-6# z{HAmc8(TC>oZZ)b?Mu8~i9wI+S*lO#0fNU&rOlG#F%tuq#iMDD^4MwF^E+4E2QQZN zBof$623581PwQU>eTp(o-06%aXwQtB7qNZ$0bG785>2*(p_k21t9UX+q#yHG(OFtX zEt-;DjQ?=Fi08Dr#EJvnpY>wz>0J!PkHy5r7)r$&#=F!DE@M{Gz6q5boK$X3mPV3! z*gj_wN&$z*UmKdj!jPwow*^fxOYjLe;r1^_>!SyEAY6Og6~4kpQPm7Y`!UXWweHT9 z*VofiZlk`|`qZff;iVET(EI#Qw?pX{R7Yd8jnnMzeEkrFND&R$o^yZ>L60;h&Wu|HpHWseSSkPt1K6T-BcAj(Vb__E~pZmQDf$qmfhLPb94SgQW?y36)4ev*)eo432F!FwqF<6(%w94 z6{}Wz;Xy27MlW?)l_SpBji=j`3)4SP(P-rpa)SzftyPA(DDPoLJ%JSn7&8hYwGc@w zf=1UyBCefhe3(2cNu_ytR+5o)L~*;NK|H~V!eCr>uEgp=LW+8*k?gt@9EJm|3U@N# ztwM^?Z)aSye_7W*o1G=*4=d&K4znu9JD4nKhDVKPgJp)SSk-oGVZ$vvIE^#b4S2I^Q<#p(cz`)mEW*C+P3~ zX2IgddYp(>3Vye$N|1{#bE=y8w$n*&K&9MRL!|_}-sNm-E5!I(U<1?cJQi>FIg`b3 z33tu_cl)g<+z!$(PKDj-hPQY;qk&mGkj=D~cbU58_I+974s&SR?9MuEKq@H6xMfu# zKR(FtSS3gOy3!HpSGZqZ(n`O;3kI*1#6c4JoMRT3@q~zrCCNQo#9lLo7&&iG0adl; zB=ukB79&xD1E?%R4`5|LdiV;bgSn(V`#Y?yqJo7(S%a2=NMv2k~*j-Yx{)2UiM7)S=) z^9adD7e$VjXra*8ZJ&5eCEYxX&U+ZVLT~XcIef&!{ccA!_xi{)Pwe#pY}Qh;jm+2Y zE36T|dQunfHNDqBdQ|HvAhum$>6mFJs@%EvTzjBQe$g@j4_1e;VWW4#VoUKkU6#(3 ziw^wl+$4GZ{6_)4Bj*MI-?3k5CqET6;1o|r*#nb*A3~`6nC~AOIUT;phh8C_an4%5psr{it{i`W#vH51Jdst1eoS@rD(=V-B z_*pv#mIU8_6%>@w2n;lzM+Ldpe&`TI#WWt*H9v2ClGPvo)rpYWHg=9B?>zkaF~=+0 zca&65N2yWfE!^spx=C*%o4e{MDZetG+tN`*zI!Lx=jNO3$gn!_a@8lNzqIPCy&T)G zx~(Uxbz8acx~*vF&o$A7)Qd*-*SiKe1((#fHG8O$Jx}ud#C+q*$f0xZe7ec7=5q#@ zod$@2C!oUQkkpG*$oeeTA#?tG)}to{n!=bN3y@j&vfTH?`vGDtx_lqCP!@V)co zHm+x%3zm1f>{eiW(UJDPz<=bxI}U@l;&%@;c$?(*?|g%|GC7vSzv<7^tN@2D?mRC^0Gs;!nYY5x?yd;ry#tZoKB zRxs43SrnKQPQ0dR<48X!F5F`Qr+)py5+*R-&xCoc-FGvpt#M72uN*JPZr6JGH2u4zH}`S1 zk(8!0$18$WmvuK7cg|ACfl%rd#KJW4eq zj`via(0FIbMJKRZ=Ar9yp2DQNv>hedsW7y~c`nYY7aA_oE-x6*TxF zViAF&e4L62VI=uLp4#mpa@{W4KZ!i*&c$sN$@w|<7n7d2_G}pu_U$yg>4A=1$tHrJr6qhTcLcTF&lc+Ba>}Gz z(1qeKYaLN%y1lTcRzBg5^Qa?pBN@wQD}Dj%bK(`L=LVRF6IU9_s;-~sRm*iajfd~= zR|1_r(5Az*DI9;guLgwp{_LXSsfNP(HL2=w6==752st?rWR0cZu1D$Mh-s%7~qRgg9~CG1P*q=5rc#* z*C_X1x*M&-%`?pb`SJiuFFtn*HM2=&qetKi;XAb~kv;$Z1USO%W8F$0_JJu(GZM6T z!X-2;3wLI3qDB4FImIlVyXCc!yY;E0ec6sjU?BlIFVIc@%X^ytX_{4ogkwuLyAsCk z0a>8ym#^eIf@w*gx^MY{p_peX?U+8&)jiUAD+TxsJq>rcvhI^46m~O-9;r`#BS6Cjl`adzRFn05-w=%v@ z_R;mi%~uYn<0Q`{cJ|`cnC@VMnx_ssn%d^Oxg^di?EHBM6CCu7)14~8vBB& z0FK8_0hSbIaI>=7If}39`YuMD`Y6cZN9cdt=n@v(2SsA1KqOXHV_hHZwL3lxHFaGV zOgy<8nC)wcp_`$xg%^x{EdqHK=4un;>hPQSZlgRa5JmdC5K11s~u% zH!B?4DpsFb(M4syi7dSdx)>cwajP%{P{pX;v$``$!*(Vr zL&2^osOB-ya9!jyZ|2?nxk0!3DOF^69H=){J_cq~3~aq109$qy_L4&j>jyjAx@Eam#aSxjo_o~5<33ldL-4rAlaDVO zV14|7$K3<;ckz45uQ%1aT9|UkM+-F1$&lIQY`p^P9_Yg`yNA*q|6Q)<9D>oPg(fy+ zEzI$byS?WuxR-_)9-REJnX@n|Z8}a^WSVc?wAh|r!Dbx_Wl-?VroUYDi2nQN1T!X; zXtDD$FJIYw{f<)ICqm1#J6}IWgaRQ1u@VH~V{c_9;BM~*?)LPU;>*Qs6Tsa*&=f&GCW(+YY>G*PSQrJ}U6(E+h=$*48X5QpC)J^Ns&WB8F(~q? zb@W)y^=k5H{HYyj$I0wMdS{qx_fMkUk=BG0x%BrAl!zA}oiHetWWNBb?^+oxLi3TC zN;cPt%YuTH(^!B|^rC>N&im z3Fz8|+V31bv%DDde?j&j6DyOU^|^4H-pC@>hb546yXhy{ggZxMn=0p-*hyu7Xj=46 z_X7;rXn>~zWsdt=M>M{_Yn*AfVtQ?%$xY};yUU4i^gPo|&QHPM!b`7nc&EsPoe5Ba z)VlfEe9tj3pq3ClYdL*)o!r1W6h^vOC-dY%bJ7E=73SI#$%N^H7&X4WD}rABz{@{t z8O1iMWgNURo<8c^Im;0cytG&}pWjH&^5AW6dupA=1D4e?raq#tX9m2mZ&o@Bd{-!} z3&rXKBtmzUTztAE)0c^wg8pedj)pYkQTAlOm{stro>RB!?!Q#=aomf$h;JoN2dzB7 zmEH?F4ao35tVv;W3w z3a!*{wRQhlKRjZye)tHLTm;nP&Rwwv;D~(h+tCXcop>Pn+!m8aeID^;Nx%*g9DsVN zezo!nxpwc&UA!3qd?S7^La%i0KubN85HKEv&GM@nTr*4yILW!1XToR`Kxcd8UKuvk zb`Ms4Dtu>q%{F{zJC%*Vf#N~v4nV_7SBUZ(Grrq|i3s0q;(niq-O&MT3+`r6F;&2} zaO7r0M(q61YvUcAlhFY?2M?QbuxnUSOb}%#*zT^}FEFdH#+v-KE!@O!3pL8i4BRa; zm+nQF#W$@mGe1VxqA&@g8R)HO%}?BSnr=|^dzxWtle2g%l9v)9 z%O^QXgp5|3wPbW3QZ87rS?R>pmrm!s*2_)t1Az zn!>Nt>BL@67!$A|V+-Xpn4_0IXpw2%bZ`Oz<-$qA4(Rb%d7t<)yuZ~$w1p|jXRYXK zmElx%b@wxeVl5-MUdQF`c$<;>}C?@Y>Qiukh z17}l1=x@#@6H&<7^k96=*<`<&vx&YF$V5{^Fq!BtolQ~Mkh7`&A32*^emR>IA!k#{ zzj8JO{tIVQqnH{pty7V%gTr!pDhAev1S);8qEae=os;rqot=}r#?Dbp`;DEmR^1*V zssm@|Sg1cT*#OQ--3ZR1O8OI=6aTm1oIx44z=aeB?ZX+o=A^r{5C5Y7ugXMGBcDIG zHYV&i3zy*|>d zo@vf-rpnRHXYZX=t#nu9t~wZqcT!>>B6rTyn0DV3#d=wM0p_dCnAdck^(m&S(k7}U zKYtmtw%ex8^DUgXrH6Z4?|K0#I|LJms)+5Cd(6^v)0tjddV_lUKHRqXVVy(@IU$ZS zhlbeWMzB}YNxF9YfQY=72R^Q=6dBjeK3bqg5>PW4156rz+1-NZ?l&t!JXP-OB?4CW zX5~MAA$nQONXE!sW#6erZZy&PB2modFgVcWK4b+(60mT!7%9DY{k1aPbp$qZUGp=OHat?QJUvGMbbIcB5V$A=3( zxPu-pLu=#U{w>Ik2!6xAh39|q7JSrg@NYpdf8$#) z#(kJZ&g7lFmoXl-A_;Ffc13np{o zy`8NBa98(8nULS!L3#5UQTY8q#nIlVy(g&iqj>Ly%{Mi?SgV_yE65l}CCx-_tt(I; z{MEvx9+0Dh+p6#T>_X28yRvG%y8b%zYr?~wbfRM3WtHD@dM9Q5Vh`c_R~TP_{+0XK zd9_%L*uVnAMYZ^9oyK!V#;BpE8)_XA4riDd#apx{YScBSN0^JJ0?OP=oG8MRLTNvQ zJ^~HKk?dj-#ckRMn>#lqP;|Ne`wP#P$40(zbC+#nKI5wLX?!^F%PNVBx1tGd)Dm!7 zGin`hIJIWf>hk#fhfzzD4H&gD&Tl8sH~+?{l}lX;j9N`@u$}L3jaq1!QOon+HEJEZ z0yAn2{o6(@?F~jP*8jw)bu9897`24pMlCYQzcgx13wSFTa>v@242_hsw|nzSwVA)) zdHc&b%1D#+f)xoF%aJsJAcLA8)^>8EzDZ01s=3)>L%SmF(&mwVZqO3pRiMu-`?erP zEOSYG6%f?<=w7$)gQb{Dh6uUV?03E6HU+!4S}~t1W_!(r()lWLQdlHl-d**a8qt`t zZI%~TOx0|;+9LKRhIVme-}`-w%C=94#aCTjc{YyIj-S|lHxj7-&q3c{3-6(Ny< zW)^3Pd=Dset5z`#NPJbU)0y62RV(beWy4Y1#;c5=U^sT6BdA)v?7>ARurcvDyLq}wbbdDmk%i3@^Z?iWHpMt*fO>4>8UUJ<2Di|lw~V>S4=suVQTDdCC4=UUIJtOxltJ z9>ht~l$5sLx9^k?`J$)XIj}k;V@5Wc;;^|PjFszUO99e(+9B$3WG2iqpq#=au^x#y zsHdEK{7e@a4%0NrLy6M)>6s7^JCZPsT?CAnsf>J-uKcI*X)0F7^aG7Actfa(cNbNs z=}a`dq+U?DeZYXKea4S_Xvlsg)1Ho*&+fisTDqLs%l2&K(WTCJi*LSNDt=>q=&Ghl zRUSfDMt}3#u9knJwrj!q73HvA!X?8?2~Vu@h(B0wbzRw&Kh0pdh#jeluh%px?u^o* z0X9taEGc$i_j5hs@ySg!(%u%;{>tztYfI8pXkmuQ_ZF6ybB{w_SWJ3L2xI!=c#icN$9 zeSFN0tNB6+&T$PC0)d)CbjJsE_>;Q=FH?W!|4zGAgOZ8*wkPuz?S)*n%Cs%xjK4Z- zAf9NXVlJ%~Gp6R@MNsO1T<@TG9FdTZEpN*|IP!R<<;J<5%v!!im0I8uBmfRon#Ji`0rV`s_BZj=FM%bWd2?qktWAF*Khdv zP|WtaO5>a9PSg`xwlZB&!UYU7`dz3mim{qRJ+|ae6uF3=sVT^ap=t6i|C~Owow3jR z2$;NPiczkeY(1Z?(28Pd?{hUJKbq)zem2hM*}246>`1{^d3D7MASJ*S`fk0HRI5^$YI(s#u{BF`QYXFab2axcxgZr2I z!;+a+>M&7*Ij>n$Ku?zD&q)=z6^d_37mte-VY^~(%=~a)!v6@3pdaCY zjk!XGh~?mG&$?C>Kv)Bfz8={88;>$US60swWqgSz8iV^~k~6PA??L}0g+|<`oKiZQ z1?u+Vgu1=*esy~_L)~8Xf79({%LME83YKWl-YG%5FTa^-{adoH|1i7vNo)xPo6(CC zCzJJT^X~5OOJ?lW`*6$NTjj^y`6ydl!i$8vd-A_4(k%3&(1Wzw$QuYhwb5TcHLo`C zQ>$P7sWJK{G&77T=;>)5$g~}8Ki$>X(-;ffvB(RT{hE!)J-*1c-Cr485{WHQJhQcH zmNK%Dmtv>SbRLn(YTMnJE8c1Bjl9>t>b~mA{*aN}w8K@UXe2RXLQSvfR)nUD#@8P) z@~5{ry)!*=i~mqe9mir7&h^@Yq)ZPMmu}uNUXZ~pTr+Z=zn>T2;eM6mWv-Rv1($M& z8n+e3q*{;zT*wRORq&Qc9 zYWw#4-!7CqdiU$m$kj(jCuAh2cfbBA-mrgy5;S`W&xFi!;>Y$0ujnTj#oNY-pno?^ z_;=g!ucFT)rXyqWZs<6r%i={*9xHr{WaFWI?AJ60kj}G|pYE%myXTdg7tTC0_Xz(w z7upuG!+YELXYaG*W+NILsfAQ;Gc9b58=St(*m!v1M}l9ouJ$fF*WJ4ItCd`D?Qc&U z&u8UWz`e>5#rJu2OjqcXJ-8J0O(9P8!zWN-7OkrS`n+1_3b`j0uvDT5w!2PSM}8)KpHG@?@xYt?uhR`kHC_sp!u%|DXy}*ma8M+mv?z!5#56ubh(?d6j!ug0Hs9enHjlCV~ELb8xahc9@&Yo`l7b< zc{{67sqrD40UJ$3C7^M2#WJ<1eHiUGOGFECwVNQS0x_&m36+LR+<-vBfDqKaTw^+L zhGNID9D_{5!1;;K;dZaCI!{+e-(uaXJqIU3f}6ko5mz6%N5|beGS+~bkhLt0(XSW~ zE(eBHK6zc`eCB`Y#T$OiiK}5lxn>qC`mKYXeE7N*0vI+m@qE zBYOf?Ry6GoidiNy`juX+y(p!QLLScr!70#ik7|ANVHBLKR1I1qVl)uGh-U5_m9Aro zLerO5E+^RKG2Yy!I5OQQdSrJTZlN##K}V^t>2jJ;J-hD7Qt2UuSL?O6B-R~V8OpiP zE&Z%Aff1<}r__8kwwEN+vk)_G)j|oKnd@%%HOKml()`(f>x!GtCy}N#yBMoI%BcC}F_s%1&j4YbXA(XA zSq3*Al8Y>{)|+ZR+Iig{voJ#3_%Ykyp#P;BVqtw8{-(3>kDJaZ?Ml&!#gi#Mj0Xjy zyB-Ln;c6EGY-ZOQ$f-tldJp6pw3NBK>6ppUq_Xh&6CyAmq!&MuNf_VK--WKO7umn}y(4A|%mo*7g z7kq!El~1u%K_PbLw!Q$hs9lQOm6O(%n6o5CI zzWQdletWY@D~`sBq~eR53Bln~t?ez5#-jd9_XKY4zj*Nk>0+#(UY27R?`_-8$0`%ND!a=eU*hEXz@!u-X+`6HSd<{LXp|sOkGh4+x#Uu`@7u+Uawh`2yxuo^=sA zcH$nJB=!|bK{H#L6cqCs2SL5ijiyCilZEmXDF4;lQHvm`85(7Ev1dql3H-k$G^*QB zD&I2RYqc91i7AE7@%PyLDcLK{I!A(JygZzh+gIjs^SJKVrRJi$yE-jZ1{W$O?!{T` z-@vK0D3T4uRCbm=99P;4`+KZ+M3W0&X!01@Y5iwNr$+Lo4TjC|_0GfidO?ewW9fN} zv}N)#?&`ev-)@Fw92Qd{-q*(V(%5SV_o?_>2jUF&Q)0!ar zbL5&KR|Sm6-1_v!jZc_LARaw=3$jNiK=z0iesP2BQJv(Q%K0q-u$(aE`_iz^dHFSz z>~TAKWSoWS?QZAb5^j{mJ=J2L`>sV+gMX1A`X72@O8=k=`!?@@7{{nKsmiqV)v)qI zb3>wUFsw6Wn&(dJ1s5e|S#Xc(hh@jg-@6wcWJe5*Xjs1k(f>d)f)KCrxz#&6yAexBKEGB8CJ*lTy z6?8RPC!&%blsr#pA+)hh+2AmO9Cv6JUyMbkszlr*RYYey``;jb_vJInKkMY|aKp>& z1iI1jdEWgP61}J8botl4Q9lVBNfK+@aju}Obf4&OA53vPhT}rVK&5e~Jm~54$5dWt zW4~tJ`Iw1z%Ct_k*?y+Y?v)?lgBcZt>U6UC861*tw@=q<)Rl0!_Dl_7%ykCr^*{CP z$*n~={d1G*(>sP!GkvS;S{@QSDeZ2qefph_eAO(m+O-DEsunpa@b*Cx>zMlFnmb(D zb!qq5W{4xh>vdr(4M&Fc@#C$gMN7TTq|6vWx{DvQ2P@=Zz-ESFN{A44bnSiW zh-{w}>u71#r0u#igf5%jr5MvQchf|yIdG;Eqg9Iax-$gQwKMJ^6mKnA5;)@&i+)7$ z66wdLK5}K9TMmiNM%G^-+Pks+mvuL0PE)q#U%y_4WWV|t zk0m0FKePNifGdRmkwB{^i#ZKc(U#-#ztR%;H91&#juDom-8AU*Kg|^A-VvsWNN3E~ z?JZwwm6F>|awG-0k5@?gp=%4LRg~5IC`Y`KnQ|80SuVS4rtlw~nfdYK?WUJj{OnGN zIP~i!cpF(`Ejz2d@;Caek+Z`}VwQ&tUXVd(0O6E7zIk#1`q##od z2xEIMCy&J)t}CDffm5XC(W7=67j7LHPnjE_CFk~efXHJ2Ias?>8+S5A+pKq{ZlP#u z2wcwnI#=IO3Sx-+NihQfrmE1x#ZC2tYIPYMs?%T!>kiVVQdD%^o#y;o!Q*>;rt})R)2@k9aYjB)|Log;WpDD5Sltv;_@Qt%g@6luM?6pH)BZ;CG zB5r_J`Ku9Q4DrtM;Ns!8lGbyy*3K6xS~!2*HMckZvS^INZs!!ci+#sM3K)jtN-}s8 zF^WmJdFI+q27+l&w0a3+N~=ZI#E0hN(mbnFp$-d0Eg_mmKOg;h=K^=8pE#k0Qa}FE zxE75%mllsFx733TwFAR((p6{f4on(n8nl`|Fnp{i6bBdhjdC2Hzf~6KU_!PWPDZAj zr?%2Ux}~ukxzG?BdGU1wReK@hc=^aK{0M4k7pzMI<9XE$VB2a(!-f2c_eFsezgTWH7gI`2?*x+{?ynf8KOl=Xlv*yP}DZQQz>U;jzn;BP zdKNoMWqcexH(}89?T5&pl?9phwOh$Cf+QlLc1cVd{z!TrT~D;@qK!r~V|4z%ZPzfa zuZQ=nLK)isL&eO)nG#i2j}SJEU)*siez7~rE`Tdk!zAzQbyZ17NvyB8E zD=xnK32(R=9=&lR9pkdhx1?r4T+yt;F)-6LneE4B3p;v%5)2V+E0~n=cfcoQo_~cj z@JCzWnq-hxuPYcb%BxvKoURZB8AXKWK*z-hyAWy@s;|9m^Ta%= zHe*q%B_#=&RlrsM62*m1(tSz+^rZ7)=+v3E0GW)z>LdJ^9Df?iq7x>+E$0Hcs4p?^ zRUS`@?jbCbLa|tqSiZfqvD#!B%&KRvR;W)Cj=pM!)6aYqWc0G64y10_pnALfxKW9A zH|m)UGh;kA-jL{x$L$@?mK(OqcQQ6F`-Oiu%Op2mu~L5J=P+G8FC|G^D>u+jAWK<{R*o?l5edMm$JiuK8Jud)Vm;!E~&Q~T>5 z;s`!O8F%)srt6g>hE06wN>Rem48vJqFHxRFrW8%5H@hNAAO2{dTcXQbn6|pOODC<_ zxBV8i;{0@xEjGILHMd?_v^=ZSVAfpY#%3mjQF{sgINe|@K|sSpdVCs$G`v}xYp4Iv@Q9dVl2VqonU>U`b=S7YUmnMC z;Bhp}x!5W>IC_?Q#is-D6(^+NEA9BBbGD07`Q_{8{knNvppS^Aa+eCf)?!DMP)j>5q%q%KL<|sHaonLF2DmeS%SIZRRjz3zaxG#;z1?Qe-COGH+u4QU~2eP8*!L2BN z*D|FMNobi$I|}=$ueVIu;9i4+Zu`@*PQTl*pE|x}>O4E4W$F^!pGP*4@4Kui=`f3W zBU_FP%M<=A9y_pulMw&3B|rdOrVA7rP`mgbh!Bh?mOfNuxqNu;Lw~6FBcMWYIjGr zCyp_YmE?44WkpM=}TB0GSo@~aAse`dk8xc9p z`#MwXHr7;kRaI>EwKn^Cp|hEEcFxAnW!mBNx&G_d%{^60{!sI@^=JN8&HJ%zT9-D6 z9Bp1QT}o@7;j1!nCt-LE~0ey>}aEJiPX> zN4w^pZ##lre4v?h#wt=X0D-YRy*xWp(lwlFl0orj|DK4U&^+T=uGWgg8PzKFoi_`H zWe2l_=GkFar|{YDf<`&`mO|qKLQ_~y)8B2hlR&o`O1TGa&Mh;HewctP^l#07svTnJ z|A)OdkB9Po`-dx)R$5TPNQz35B)h3p+E6J%OtOXSS;mZ+q!1zz$uez7ma$|XOWD_{ zEMpzJiLnpHnC&@->QjBb_x-w``+5F&p4aR5N6jCu>pHLHJhu1oK91wQ-&_nABI(WwYu$*fgq2R@f03|q;?_=~V4p`4%eY>CP>}=)lqB*MrT^>M1vzDVy@n({itbPWbE%v$v`jZy4E$&TG4wE z(uD#H)%MiYD}Xhrk!_W?}PaF^NBXf*(W6CEY?;_1{szdzZ1D7&+o~ z^qgfsV!_k$*^33iZDD{s+928(shOi)`4$N}dxiZvSz&v{n|_gQKaM7eC7hbm{MY^R zlBz_E#0Rbvfzfe4CyQ>yMW4TYWjc6513X-8UGceOWS_#edP z9CY;PoRKI2Ev~m$w6fz>;EOv^#>JVsoinW>3{T__1PU&}=|xs8+F0VCHSWcxu?ndq zC@Loz6G-@4auBFmVF6-+q11LaBIL;8jxwNzw}+hyz%=jBkaFdNdP8H*C?MG@ptX_G zUS(9?sjz)}Y5t;7A;>bP5UITB)D0 zM{!-$T=>(kP8W>Ihtr4k9+4wJ$R<&^kfN0D5_@K8P+~y0%!XPwqSDplWM7ySh(khOt2?s+c8K1^2K$pN&R_|SpG8f#GnQq1<&A5R_qC?5+ z&#U)q4vWuig+7L=8a-Kfa64|Z7})iyj}ImvP;qC}1J5CRxdq>aWwK^0YAWL}!v^W} zaqi@J1-4p$`wK<|wp<49oK(UYDVYU>#C=|58OGi4TJ2>s+OA@Wz5UyGL7yzC>1)CH z$31s_!glT`q+x>wo1_=6ux@BSd$tgI;QaG)`~WZB`vGKfK6!!EHvk>3^Wlk4SlsIb z(HbBO0r2(_C!iM=zPilaJmRpu3fm}pX)7*UpyX6Zz3Ejj8?pqtPWKU*y6JZS`9j&( zWBz!>GyMB%%-mQ>AHrC_I4yp2cQZ?cEHl%M)#Z9r{UI;S1G8z@MbGYZzgV8T`=)Fu z78pg5wky2^(hqbxaGHZozlFwxgj`hTe-fLMNfU|m8s4E|_fK7u#8YvfV<@}gOmWqt z=LdeBT9>t%)1r~(s7}n7qjcF!w$Xp@j`zG4jc{^ zq;|AoFXd}$PR>AG*#*NTN9J9pzl_RaO3;!vO#`7E}M%J*j^$4X{r7NAz+q_|zpZzBBzDd;!{EKC@7du*d^+|QFA5i!9>VHpud#N*aZZXtQ59ehj6CiYk0}7_|?@ zzWn4vAS@Jmsk`hMA^AD zmOy^OTyaI0IoT0E%A{LE)jm#|X6Q(|F_pH31HH+M)o3!Rk?+*|C8q9kk>9Qmdv*B=GBOio*v3eW)sudov0wDJN2yj~>vw3#&h0EYg;o@zd{YNHKaG_UtRf#%G%X|h%C9J-@*^IG)*>{)0 zA$-JK>Lv8oS-+{fr7bySJ6+}cf)B(MJIan+=foAyK6gGH=);VUN|Gh!=i=e0SWKHuYALKes{dsf?-)W-Fl{Orz*-gueV=5rAAkl6wRFK3x*$Nvhge9)s z5PIFoIAgP>*?Fwce0r1j*YLR*5t6jSi^~)PwcmU6iNfbntz^|^CX9Y(QJaQrvP{9W zAw;6;j~f1Q{Nzq8wZM_!_U1prauFXvvgEvpibPh>Z^4wxSP#PPn3uo^Bjj7xj1^6@ z4%}`NK{x^?bXM_{@5nt4}4uZ?PLP#|Kbs1d0K*=uHaY-W9 z9~SycXjPYm)-Bt@tZwmfRU z@A*wmlh!(mtAgNTZ}Pro!BA$B>A5oEGZyzHoB(F)L%7s4Dl-xY^TEE8X$R`22WtFw zzMn7@IHq<8-hrky<%6`-kkZ$Er!Eq=T&|l0L!8ZI_nZdgjmGzvuN0F{iztp@uh zS*!QnEt&hUke_{NkB?sQ1NTvJ2syYp$W3qDQ9CTCP-=#^bS-}Uf7qT;7P zm#F11Rv&*1^t0us-4-Bbw7U>tlWpS$9kM@%X~GjS%)%?N6@*+L6-#S|C*#MEWlsqWFsiwFN7j^E1Gg+kT3eEC6;6ana$K0--8vckwcNWyK;GvD-b*9kzu(98 zANK)A??$;6D{D<990U@UaZ}>AZI834j{^Jy0nh;iW31#!yDOrhI?)g0g{O z$as8AA`o~X*`Hn*0yvxvV^i4-JbMnxB12J(g%D9c3WiC;mo%bTPAm$ZfG=7cX2v)a{LLNw&7L*i1O8SB{+7!gr1Y>b zY!;M7XVZH~F!G^>GBhjKNll%lMu1t}9%m1|6eKVfZ01P2Q?{=iGs}BDu7POiYLptN zC)|AVg`q_9f`b06;~|}uyQ=B9Ul3u+X3W)!IIxK9@)^#K=mELM|BL;L)W-hbBA){c)^SU9tPp7AQ$?({LGf9$2~Qp-^C{N zye~PcW1Hn*O&FTHu!CWTb8nYZv9+yy?^Mo^7K$?#X(ZT5eP)-eZorsT!pDq*oK}va zfkF6WN*Q>sF9-oc$^7>D2X(g zJTsr4o?-I-*2vu&d+OtLTUJmr&0nvuX?kY6mPFs^$3%q0pyo*^eJSne9Xgt)Z#@Es z^sIPwe_;huq^P_7NWH^1rth&tC8zEi>FO4xt(yhiQ0x5fBPx!zoDdlT`0pYjNV+OD zB1ia6ZcJ{6;bujg9UKfU!xick8k4@<8%eI4n4F%8%YD@CvgJaJP?2U5k~jHmz=@%( zp~|;=&J3mMicysW>`!fJEzpbkEE6~C|5O7+Ob{cY=E;*aV^ivNu}_*iSPP#-$U(O7 zu)c|ud{ph=7cISHKmT<@8U5;4?)&y%Tu+8uM1n zUom4*A*^DDSTnS|%f_!QeLa(*Xfkxs*vlpKT>By8yKmU?(y$ zY#TPIL?G3|lhMMGW8IE*lMY~a>T89bKZ?C^rCC&F)M7=iDB)Ta1+$0tfqas;dkVhP z9+I-u9bvMz$PM1sH^QiNs58MzaK%E^T>La6@m%q!=NAn&gGPVySoY0P zRH&cVPQ(|w!rn}x5YsfiYB!IAfm1`w5#+o^hW3$kmse$7sl=2R68upt?WO4<5AjES z(h2oVGl^;%sFll7uJMU8^;82JI^?IcEO-Xqt#}&lDv;H5$*IdO7p2HNI$k;12c7PB zu97U%xSu;dTYX8?f!lD)q769^}4yW zxlw;n36!%L3^iTC2YzI$6b;K~K8Vm6O1RfyD8Fj;?sWGGsof4mQz;j7{lD|3!dxP% zTP0~qF4S9QI^)Cj^_3jC@b)4*t+^}-8zOC@zxQxt8oq5<%=M)NOE?+H4Jq})xfb@n zm^7_=a3*EO;HzTtx9h|QLpTN1W9Xp05##!eNG*28G~ub^{UIZK?TXT#NOT$lZ*&NU zC{H5n&D&9f7gW+18(J?a>OX!f5w%f#3(MQ%>hi5K)plZa+?$529*a!L_V!J51Xa7E zC%RW}VVS72WuDosZhmn{lL!Ks!$t1j|9}%721uV##6|7>0%MhA)d#khP za38P#46R(BrgS@#b%PGsG+%t`%<6R~&UL;_UNJhD%!px`TtsEwOS5=`y!jHd0p8}9 z!ChplxreOr#XanV7EG+VaLwjIt+yi*4l6|0P}Ih5fc81+M)prfIStOzwJ)QvfWX2{>$!!{&#jqa9Ar4?2Z?E4y~_ zi|wG8?DnFtmaiJb)KyV~OX89MZ368i57{Z*nt0)UH+Ai=5sXsZvW=Q1;+7Xenf2kv z_4a{&FEeJL({R@~+RINg)iPWXe1p^lV# z(MoMkrz$;f$4B`*xehvvW-(IYmf!SAXm4-Dw}3Zg>MgA{%Pv)LZ}+{coRPTO#lh^G z>-{UJ`z6iuDT|@DP+4XQB$M+;pN* zco3!KcZhllwI3q#xk|tbD~PLog&ba`kY{&yy~wcroaK-zUTO?@Yi1c^Vni&j1m=||>%C4|mCs>IRJ=vxan>P_f z4*&GAc|C7@R<`Fl{}ZPxGMkn?I$t%*c8#xfsNx*uRGy3W6Y&^@Y2UY_%&wFV~p9Hi+Q&w zVstKRZm~sjNNLXa^n(+7?|clAdeA|;0JUm^DI_Cbj=)3b(TN1yS-meaNgd(ZOUiup ze459a!PFgbt|J0lnSB)7#%=A3d!e9O>F(I$u9&Fy8%x&9K`m`rXPb)h^CrM-KN_%G z9f@D}+S?|mvQ>W9&r-Xrt{2oArN>ZxK_oSBVOt%8Y+0PZu3oTJT=4y%vsvm>8JHEO zRZQZC58I|q+K$L`&6hBQhhowr#f5b%?tRcLxxRHp$qLn^A66nRfbb%kJpDtE+^iJ` zb44f93bC_&uj>)T^#p%weRHT;+LENEGH#e7O=7Kz6QFhIFFbEFrVV_3-VEx7UjX~K z&pvDteukqjiM@Ticbq4v2cepm8brH9r?YK1mZ|QSWs19i%G_R*O86@T`e~1t@bxY)es_3;7t%T-*2Gzo5l?oi#PjS_{SWch za)2WKSAg>0##?cw#O8n|vxL}n{VQ_UfZ+#RY~@{`198z=$TqpJDh48IgWU(8o^K>Q z_Z+relw*R%m)|0|hQZHIoyQpi{!L^6IVgWSfv+8Z$=dAt%zbw$sDL0wpA>}^jKRy* zM;khUHpkmfF3F)Ix)-KtwrTb?p<3g%gr{WkTR)u9nxi#KZlxAFp+|1=Mu&50m)vCA z?@>;HRZIx(Y<>71dei~ClnY>d=f3bbEho&MCY-ITTqrk%cPM81 z$|ceq|Le%gU%DzDL{_(QVx!BV2tU{aY{#noI zd#4`?gKlUuZ8Pd%+M1;wRchkyxz_nA-qIUZH|xq43n>GOOYM+TA$#_OR|U|eSMCas z*_T3k-YsG5w$v0^B(XOx<>dG``)V5_l@ngOlb>8cN93)X*eFbdWItrgr~7nxDLcZ{ zr*>Vj)wY;-8NS7N-PA+SWUHmUZux~bI7m6}45>P0fM>~J;0#)nT$<7*%bC))kH;~@ z`IN5;7qn?OAu*o6;vwSnQal@CcnXDR>l@RW&iUxPZExX{+Jp=}+~mF%l>i!L{(U25 z?M5=hF3tJ;v)Tb>?Rd?Dt=S;RMns5a1>qApLH6ROh$~fD-|t4b{ua)?>#X7Jn_>16 zOzIxzUX$#hh3Es4Gce>8#0uESY1fByxR;2Ah+Mt8NoWt6%KFHrz{c4O!sj{IIC>sC zk118A8}iX}v4(rL@70{9AJzjs4A{d;ag%)I`Zsw!hkVU;;kV`W#Z&@I$n@Myv$N&S zru%sDkf*&Gx#_|RS`omd?LkyhVjnC7kWXS66w;)E#7X?Yg)_p#6ZI!22=}U;Wd{BF z$$`kbU#TxYC2y*o^m6j)tc>_#I-%#F*GR#AZbUX55vYUoGef+v1xHBzRycGXz?47cgiJKm;E=!1xIyY0>{2Mf z|9NA%<8Dx;;d+N+GhWyJ0;@FLwM|zgRl^%wN5yup+R9(2&E*>IW0)p1|H6Xzj0~OD z!OCK%8K$OKUBn#KTHe?n=KRoEE1)7=_I* z#>NviwXtVh!d*U_1Up{hZ%Wc;>YZ7^ST*%-dBsJ6>0^8fN^S%=ssRs4A>tOR)ip6OgU_`5A!i}3M-zN*RZNoEMk z%A+08I#*aoytHov&+_dqJN$MD7Sr=%Z&fKIfe@XoVg5BU*GtAz zmT_n);Lc*QIP(xvE!a1>Y9Y`)T5lpebiHMd)6M zScA1TK#x;&1dkA%N0N64uG-UUl5t7?vZm7ep#m0UpjtK=L>wLBq?F&0v=#`>@$!GE zZDnqNkRxb9ouczeWacCYN4VmGLb%wjAKk2aNw=iumEk+R+|_SiHYRYk^8|n0wdL(h zo)mKvjsyT9Xa0-L?*QR=Fnwhx!M|PC9GaEzr^jIF2)z|=8Yfpk|HI?t0FfQB-WZ?k zHu9k9Y&XsSq^oiAzk(Z=<=_VYS8ziYrg9BWj?BbiQ=MTa-j^bVk=e#MV2AgbL>%Hf zVQ1*v(2M$X0Zh}`N4+VfovI%lu$#U5C)|qWpoCi-rvwnOswu@Pl1_$2X)OTi=#q*^ zT826ZJsNkFw6i}BttcE){S}gM%yWlb7xMuE|JZocO5Mk3DDJ`K0K!chQKe{fZsc|G zGp}aaod+`Bym{}JMwR6tgtY)6EchKEg#O<}2+v2ViPD_XULn-Sw|^2IOtbSp#CrnO z>z1N(GQaPy7%P2|w0W4?$TBfyp(j;tirX|MUHkMcYrVuv$vqq-?%U{wSI4FEEx*VF z2c3#L^S%1e;6Ij4(>T#XuDZ*Lbs$ee-Cwm=t!|T`=xWv_ud46;1~=X64^Nc#{fwd- zz`)Phx_>_DPbd*f@do6kGfoC%ms>ZwK`8g@gt>m^81p-cZb?Lxw-TyHoGz_oU4d`r zARnj0-`(3#tuKR16P$hgb6`yVKb=;za>GRDvl+z9vBK$|CW}}{O^?EXHb;OO}{DMP+F`kA6lD;NVW zM?F}&dtt6>-(L%<`)$7>z-j-vNwtef-$I*cU~XdiFt?IF8HShf&TCG9u`?^!dBw-# z*nBnm#=M^2F;H}gtnArql`=EwyrB0d+xK)U;w_X9;-Aq|pJ#w%!n1wYpSc#s1xAR_t1I zhoop{1s7>YBp2eNEpwKo@^>S%6H;k!ZQ<2#-LmA981D_N`w_CpocD`KaS_Uc8=mX|cM^%0)Wd3PBJ4Fx=%Lxa#Y?62-t{HLU@$|Jr zD$8JleVZAG(ZIYJkNR5A?A9jStO#nF+xqaWDK88 z!?TD6DJkfS7;T8i);%9ihu^Q{wmg60%J2?!;^z`Zd zAVv47xq)D?`P%+?0C`anNz(OCm8p(qmA|d=<6#9Yp!G<~S))L<& zmW-K>M@bs-l1TO44#8^EaTE;@(t*J5I|9!M{9@6K=_LU>PTmO7Y-bu)zMIQ=QJY0O z|Df%5adYsRsGVr+&bMX(@a;^H@DhPT<4khd3}j6`?Rg1Fo~eKFW?828t-}N~Ryil9 zWz`C{fAL2*mhOv)n=W25*RTf79>;f^!Kf(JPP`ya$of_9Ax%%Lo_CA?mZyBu_DQGS zC-yK&v(!66MD@{lJbs%>uUTnXceYsQB&)0Nz^x(P2dPdGd3P}})Gn7t(XgTy79PVj z$p^HatoB|fWf~FiDmc~47_Bq?$qTcI5dLs6*7r>~$1TZ$0F2WK$=J!7h z`65%Oy{YSE0?yBl{wj?=IhSL0Qrr@5m;XBRtKgYq{RKqG9Yk+;HUJun{{$KjM1o9O z)JS{#BXXtL?1BE%?`Dh>IoX%Ow6@?^?^6hKRDr}t(HrSrL>J&y*(nKO1axdqSBr7J zrF4$U{{7J+V{RQw99<==JU-%?XJGvVreX0tlt^GXX?BdU9NmC->u! z@9iph-V%ZrPhawR^hyR$I>3e>7ih;Hvi&O({C{U*rR9b3e=iJUqwox-6hYlH^+o(6 z!-&RWe4M&tH&^JM%d|8p1*p`)55oVq(g9D98K`&b7fC{&8SGC7@Hckod9y~npt|ZQ48O9Xl{s+cvKiVOY$-Gc# z@j=TXux-mr)f@urvesdhbq(GjP78eRh3xOs!Q_wSgx4!K4A1qhd!iHW5T;iNLH^C* z*bDK4Pl#`?75go_0GV^w-o3}U)@DIW#NEwLQx4tHv^@4t%Bx@^v%lf;N7P;QGf04_ zCZFXbP;SG#K_}Id>~>j0xInT<)^n9#;3<^{B<{RinQh2`g)OgD^`0yTc`HHBTc3Yg zl!EL3Ktm@)X8YBsaV0Qx144$lxJxNJ_`p7gS(CC4oDZ1NX4Rbd9_d<3etA;VXx;)k z_K|;$-H3Z=dee{8GN%fYY%dAjSzPSU9X(LO#ol16WD)rx6&mLJz9s9RzyG!`o~dmx zFX*F6!YBP3yu*)jb0l!f4YmR7nGFKXz}EQ#6n(lav!dgk^vjw~{qfMpa@hA@_qIB0 zvj7bp)s2o*oYb!P8}M$NmbX5RY&;msAMXwt##}X!1}!5)q!D`-Yb>}yWr>$K*{||B z{-|AB$Y7S?(y8;+OQ(j62`#1QY7|2GTc}c}%J+weJl-k>knCZ9(C?9~fwCl^gSPj@TJ6w+N?*!AK71^UQO4*Hln@EEx zq;A~>KKS-9C8dcvi|plG@UXw)nF_*=R*KEEv~78ywjdNxh%!$em`qg&JuLVto7TWRimWY z!r8YDkKu0mLPb*bHi0|0Joq9PTXp?JJTe|5cP`YYMiULecd)RtFA01hu4AXR3563f z4MFn#Yi8yk$XWIogr}`k5@~aqc1du%S)^+EUFXXuZEiQ%m0xL6AC~9M*`%F75mij* zP01YwJ#By$hBb+m*o`|n+%tD5$HQ-Ne)$sg0NAm$C&6<6G6eqx<{lIrSK(AO_8kN= zAPd6C$u2AU8eFs$O7iCXUU^}7X79Sw$mo}^m*J6<=hV6N{TNM^5hITdj$u)GwPRgcF7bQSf7mLv8{W~m z>d|GL5;|URwtGC+Q?*=iPpfU(8Ll=|mesM-J7)dYUR@jR(P~@g-Af;lD_&Rp*)vbG zC&8oLeeL0tNm4^%b*ylE*xOT9SvKYCZkR~TGvIszF!YTcES^x`chZ6p!yViWH#E5U zT88VSaKF%Dyz~Gmh`-VH+1>A{j2L>6tA@ko48z_28b}APo4kCSOt}wn@ub5LscSM- zbhdR%@|p*V<uJ5YaHmsV*NW*{()^1KGLV6C9A7DpHs%%|I+Z*SnJ*17&xxLE0wI8J5jYL$FzsL)hQNtUu_xCytV)nU} zR^9h2dj`fMJdV747A8K5KfsbkVl6mWlK->tvn%1`Gu4p$RC5EvEB8G@p8iZz zata<3G%Xpuwu2814&L7ia6Ev^{2;LeJ_VC~)t1f>{gq5zIz#2ZJ_Ck!_JnVIISDZ?QRJD%BHq^8U;k|AoN}3yo9I{4q!Tc6w&+G^<9r&QN>t zt3z;r-etXIa?owO0QUWYa@itEq}X!Pq*WiO%d2tRmzuTOKzd8LSn<~xlmM#nMjuXM zJ@0ft@!4?vg4M2~2u>7`SIm!L!vh~#T`5@mkQy}Q0%=1}$A#`({)VzdxzG6gLUuv1 z)nG!7>$L(_>;SImLYrPHm5<7pMugW<)5SCPT%+A>S4_ToooF+J(^qYC*q-I;jA|@1 zDlh9O)EM)+KHuh}{sz-f?fIb}&;(9;PMsV7ZX59Av!6$fD#_m z_kxm7c1&r=n0FWdL4Z8;8-CmLgMqQQe{wwiYOW5}sM^zYprtpjKZr=cq5IWOtOyvfZG}@RGzLn=@t_gVMh9Ut;z-EN>=Q4LG+9qf3U;K*SM*7NI z7p*CHx!(XQ?dLt2h+o*Vuz}oXf}}U!Drv@-de7lvXv@~yR z4|1mgpWmbp|B#Iqk>TJ9>a~>^5hQe|x`W_2l>Sp5B1QSP^=b)cR?oYS6| zFdWIX|GHqwRrU<=n8`}RufVL?T%U{ktQm^rl`1>PUAUBmpzfH!i zk+O04OfEQ-s@LxEHZ)bll*iddKLxvfwp=H-@r0 zi0>fAL((^{Aht8*4PC~Qll!-hT09a$7;PCdZu22>s~Ly}v69bEN>(N1OLyj8$6LGf z(3M@U9hQF%&CAKhGz71C@?t2vLp@PFw&hCmo`5^h^v>%gEAG!k7^E6TIJ^=&d%*0p z|ICee@7Hf`>WzK%!0aK@Y+Vu4Ok#V4Mpj(*$&CkPQwcVR+R4PGg$H04IJ-@u)xzwC z%b_dh3R%LbSvN|uA2(*;T=vU~o5NGTjfoT2oOzx`A%!!&bZZj(7E73KAJ9w)cd|Wo z8zcuILo;e)=Tg>PS5Ka8^1Svu*AT8(ff^fw)s^p^RYL{qy(OT`wpVx>t89}y6+t-2 zY#AuJd~IZM+NGA&NSTr{H%o1LtFEfAN8o&DBb?{_8&8|qiE zhpp6-%^|G)&ZzMu#@O1_t#qlvnf;D8AE@}(#bOe5Oa5N9555>onXR@Re4SQ})^`0@ zniqw~nE~#M3;6l{>LV8_qOIir0YbZLIY4N!iinw_f)(?ChelVFVrfI&dcg?`KhijT zM7)y54P%zYDRD!WvHEmZ4c}PNzo2^4I)=G*owqCa`F*kR&;1RZRjnZniT=DG_tU~* zEaY@u;s6MaXzvCeC9=*Zq5ejY;W7cN78w;>NqVgNwSs0*X!>mqKZo#0eR(R>vUAT* z)m(Lq4|d@OUaC;5KzOGbXa(n;)D$NF-ne740m$IJKhPSHqkqEw??mXOi5H^mb|yT| zcDTG>x7^1{YT^BfryOdGf!dGMFv`)qdHRsDrlrU~v8*!q6yItehmI`~7ZKsxk9G+z zM9l|x{fh!*<-lR{gzf%|&7=08*gT%o!|IuMdFQLbbtv_#8EMOGp%)fNb-+OYdD$FJ zUe>DakGyQRHfmkuBzMWYp*AjFnbwHLfo{Hllq)rVn6)7QD-PV{F54Vjw&7nC(lo%& z$pSI!>ehC`o3;|KmTghHl>&O)Gj@68(G~F1$i&^n{hnW>6oi{RB1$)tj&Wdcf^D^f z5n$trj=9_jnRHQaBjs6Vf?OAyDEBLUx&#Za_tg6&(|^R>ipRMmK_dbo2A$bi`o(rF z_Gs_=`|3Fld0cWmvz+5d{BFaxz8N>>w@m7z6?%n-F%MJ*eZUNM?xop%uNxl%&eYC^XRop^ zoxS~8GYiQt23)GHi&rH$45O`7sQONCz-)9z9pP&Kjpbp#IK?eN!x1@Y&uLVO*CZDL z_IeNC%)Z;#aD9dA%ypDDns+bM`mr$~LYMYPvA#RXrz@WFbV%JTUG&3DO?gph8cKI1%*&Dz%a=J1M6@8HLw*gobU#3)opPzBV z5~Y&Q!KD@RK%qPq?0H@b7$2jeOt>H%+;d69p!)#NmE(+D?!o7JqKrHVJ&KJ*@ zwo}?NQEj*6g2Dlh-3#uX`mEosaZz{5H&4##esmPdjDZ_)2{yqTS!y*54I2; z!siIN)9dm?HASQW9XFAY_JhDWj8q4FZ$Mymh*~1B+DH9KV2$^P&SLT5#3nBNeBC~j zd!xC3+YMD6nGGKB``I~A)j`u(FKOP`zYPcPFT=rxQ5`Q!h(*@I%|~a=H`_$IY3Ox! ztQ_Ss_!slCd7{bGxr(uXpTJXY%1H`f_CRn_jhbs7aPo)v(I3R6SuP%vL#g}0WO2J6 z+}r<}N<$3otb7l>xXeBNKTMk6nKYUZk=wzvtdL!8sB}|16KJ)qd#mcb&Tj%uJ&zN& z85w~x0JU1+mTbbkZt%(F)Ef9oIxG>-)TF*FDq-|T0f}sWHIL~bK%5!7@dukT{=Si+ zh2!25yVPLeehB{~VQNO%u11%ez)(o44t@KLS8G@Jj&tnpzmF};TRJwi?T=#zy}LpQ z`?(jQPYb zLX5AK%Q7M6b6LItFXrp)ff=8~#54B{A^7pNtWQCS62L~c$-qwl7vuU<$(>6j5hC=> zg7&t4bJ2eHvLN&GI-#OL-CMoPe(MzeNgTE_0hKo}VwEn|BTLiFtNpE40Hb%IJeM4^XvaM@-z!@0Vbd>_Mn{ND zn7*|AhfjHYDT|S%`!8RZHO4$?Z`9$;$Jm{_Bo4zIHri0PYwcIwKBt8F09)C7lq2So z&T}9{#+~@0rKc+>A@u3`wC2PV|0JmxFOgKdcpr6j1b9aXhxqWgPzp}P(d8UGNfReL zjXG{CjyZC5?NG!u*n*;-xun2q&9P)2+aF`skmFL!y6T4if4+> z1_d5v!!;f(F{yrM(~B-EBgp?&871D2E@Oq4o}73h+&|3OZ4yMcdXXAC;2}F|+IMp7 z*pIumef}SGJxl99==z@jsOu${b$!kMQr9Ei-KU)30(^1P@jEQay%5*b<=VVsB+B`v z+B{Uh4;BWK$vYlrFh_0!G_;iTsICYkXCEpU=x7DhaWq=abf> zpW^g1t(6g;B1(=PRiIgloCoIMfnkxP9J9TJW-Wjr`6%{j-|b$_4%OM9Yi1Iv;sMur z6>D>~vph?BS*zT+naCr=6eP=c?J?xAiVF>I0GMsZL_2 zf;sA6g)b;3l-V1W3vq*YJd_H-u0wKleipGb%pRq-SYq zARZ{;MNQatPS0nBmC*2*28mOv-v__U4n(aTqOT(~sZ!;POd4Hi1Xu}*x44nL*h4}y zC%Lg~CAJm#w+_6^()0croo@faw(_{;i(##6D1^+WY1)1;Km^Ec4q zps-CTsfPeZ$;BcGH6MQFrM%Pzg5r-nh*1xB?;fE>+4{F(#TkAC!<g@R_x__WUYZMS zRXOk&@6p|Qk>`8xHS&X)Tf&^(v5~x45R#mVb~&d&u(RuV$#^y1_+CZ0>5mge1?sC( z{e-`Jem}B905Ws40*PiAh7tRIZYPy4pvt8unWndhDPQwgH{RN5q0+tHq$>NFwy#90 zE~v;sbdZ(gK0`mN7kw^Hodaw01Qc=mDtsBO)5X`^>Q!RqT7i4`Lb0@L{NX13k#s6b zJXbv1VNFl<_>H;yWk0TeF~pw`^INZ}zCs+oJ8$)d``rt@E=wp&be-h{eRE=K*|1X_D80>=*8e|CJc?o7PPat!Ha058_fi*z0A zR0|%ymz22#&mn}b8uKMe@+y6;i&n|@WXQ707{bZK^HKi3+F0U1PhU!|uR?hR*iH5T zk-E^yoZZT0C4SK*q`R4Ob=QAi-FNxw8h>8>SPc#{KE~aol3<}U7&gWb{1i3~@0BSu zJ4X7~67yh*x11$r|BD9*SYG1HpG#c3OJouWT?2P>T*@tN`!&Em7ZO`_O_N@+O78uO z<9Mzcst>b>yNFwMZ0GjK13K}b9ftefS`@i=ShH$?d#8)>bcg-RXqq7AsQj?j^<_zc zvqF#f&7?jgTjwAyL~c$^tX5LE7ki=gRYbT@rm~(;vr4A&&bgeb&5qKJ9#Xi6481!8 z-G1FI{1j#nq7CnY55I9&OLh41I_0SUrPj7}R{3jzPJ|gT)JElGriz|%{|f!K^@4}j zqTV%d^N6>+SdYQ~q29eH!%CUMkj?|a7EsZo7y8CC_w_q;Zd4MYmu*J?$972lVLL`f zNBtaW^j=bNj)((Pg%-_bwBOxx`u^y9gTn7tmy1Ij)f!x&Swlmrk!a=|nc7QcVA)28;ywM zr<1gGuA^!V$(t5tKb}Q=KN3mPx*SJ{ZUfrb?6q1sJ+Vk=%4EEt)`#`cteUr)%LH(2 zb=IKYpaxz|j+}8H^D*n9#?n*Nx>a{X5$~DI0s84tVJUl_LuEV>&M+f0MfCBjsZb|n ztKXGrZn1ZkSYm#a^@*w(Orwj*+*b{gkrPfzFozHN#fhowV{C99j~Y=RACo%L3W)@~KN3ElbTWmlfuE@YrBjFcf_j)C3<~ zaLFHPVnk6DpGaax2=7B6GZ(l6>S&(2MKfx4T3;XmL_$w~)rTJO3#mFuI#Cj*dO+#H zhqnp6M|^Cob0zw2xu;cOV=H6Bx^0t0_w2c*Ile0>t2@8gq7XLXOm}pbA@)E?whMAz z>_Z1T71W$7TU4PZ%(`}A_;roD70c7BN&sb?>W7% z2lKv(ZNxvB!K3W<;drayTYFGubbI_IdTsAT-AQY5`FI&gYJMA1bZFOD>-yQT*oNe# zBf1MnmpqX(`QS>Ln!E}6ACDJQmCbcTO?H`Wp0B0#d>yXMVorioM2oJjqQ)?P3;VYHq|yGE>TsKx$Yp$nxCv# z`PAs@;HJ{Z1fty7bk7~{J=qRQJ>R`=w{Y=H-T;jtW2o^jgHg9K=OK_D&4san)Y_~N zt1Ais(TU&N{c`2PU=|9~x9bigEaJOrhx?Fdx#?kmI-VaAtCR0Y@!O+*6knBY5u%ya zu!A)$rq3yN9ipe`Q16OyJ=b;C6C?UZ( zha#tLVN)OdVHET~X!(jdA13=ltr>2cKGE`qwbv+TEw3l7h-K@ zTBUfF_DLrJ0$VUOz8P;$yr|R}zvz{qA7^*`8oMFV8N)FOq+*n8*`|YTFbdMQLgW3* z#5MQy1(#hW0vEdHVAmAV7p!Q-SrPhcMf~q8N-eL*|JRDpJHQGFn^o#oTG~xbjp12O zcFG{e0GX#o(Y8yb(dk?z|F)T#V-G9PU{$Y_;G_OrssJ%g<7O4Nl=RaM5_IFRFKIPR zg$&x=C0`9*{PH&o#Luxn`v2dwKt*D?K35!mh}mc0=RL|P%5@;BYPNQnsZ?Z)k;M5a zA1*?sF3{K4EqGFJGiq9Dy&-;kT3+y=ZMXjPML6Nh|9?zS+Zuv?TC~3O)Z;+I4sO4; z=C6H1M;2n%5OOcgOX)*Yt`(u(#i(j-u-sjWs;CQdS5cJsE)t*{w&Y`tyJdZ9y9uor zA?~uK6jf?=c4sunBWwQ4hb48bb^g)|4VvEPxnrHo3p*MSz!k^D_zEq#;v2UBSG;?d zEq+%Z`KxWB_asSD1j$0?0AiSHb6Uo%%l@7Vd2yCN(|^tfz5+8$H)JUkG+nu;%q-i; zEY-lwNzHTo*c6lT&IgadA3uHieQ<|-1d3N)-ROw8iD+x6b{u{7lxQy+(8DfuKmW99QeH)Dz}M2Wrg}0K2X7qEPf%K21wpxl^ZT$p!tw_7ar=ix4}7 zuO**?Hd)?;k69jBU+;0itciP|G$`_zJsrl5kNK)}(-ad!w#M`2NH{njO{{du|1b*J z%`Li3nu87Rk!TR4??78TfnV7_E(umLdKKe-^;vn4R7lmc7s8gf@C@q{)25Xhh0r)# z+Cp}}R{v{dJTTj^9z$Xz&qLlkIg>AKDXX6tJ^ch$?%pKfEhuBrHEG&g z8nizynN=xr867F$3v=S*o~n3J38#6JiH7e(yFU)b@hk1dE3%* z!RM1QH+3leA(l0)>)VvE^U2=4{YN4}8SuMZp+mduT1^@70|ORM8cvl_Ha&acG&Fr< zTUc38bDOboL>I=jtZGA-oJE8^-LZcAmU{<1@}%m%btNu9WJkJ^Dd3=t~d;8E)aVISwBcVFtJnL+) ze%X<4mUeadAj04q&7X!3w>bUjiY3_dnYbt1Pzj&#YS73ts#(2P!%jnX5BvCJ&hg}r zSIBngoAD{;@e(2a09T=Plg@FQ-`aBTmer##Hdm?^?NpG+6X*L%(&c~;mMm1FLa8*d zCLs*;(3-v&(Hocjtk8selur6;LqCazW>;YcV*N)U z;p%krw#jp-mB-TG=;_NI{TAahzTyfDGpYePj7QA6y!a!_VOlS$cB*&FXyPFh_P zKNZm*dqs^j|6rQ)@|fIdv&p&59BV(ZdzEg0MAD5`O1aD05%60ZFwVtyx#jBNw550T z-}B7D>G_b9AF;oGJStMpUe#Ed_}+gbXFo1IzaKX?4t%r?+4i1Ie}a)|4me% zOD(|Hy8!NxuqK4?#}=J;O+3Rc?D4}JM-AUtQ@jysaf5%A4qbM7vfRiNbf()TUZl^6 zZgmuuH$ON|SnVhZuz)$}DkQ+}Cc#Yk6ya;s#Q=5}#{YVR*2B4vq_=e!gEePZOThjg zfCr%24*SBqbQZzjZ|H1D@9ZAbN~;B0@3=_w!LLkgCayaR+w_$wk!jv_! z_cdLuB$F6G*#>Y0g|wF^yu|A+Z@0jGi{tqPN#)}2lG8uhGRGo_n(q~J@kfiMaj4?; z*pcj5e=G%3Qq_!&D_X%LsbVp68>Xuk=wYM}e7l=RRm(*ZTKaJ!H&%*dq!I?Mbd@|O zR?NOs?T=e4klClFDnt1yc|KpS1D)0xN}b#9FBAjumNvLA zsAp~O#9DbE^+W7}e_i`o65Gu@@pF231ferHi+8ug}or34Z&Yti-`MxD&~wA0SbTNL8T>R@>K)q_q^sRO^bf%5^8%S~B#x(mm_;44` zUWc~mqI4}j73DX2_Nkw|m}rL24rr&7jx>xY7D>pOahgJ`H1QJ95)A1-=xVkq3#|H` zFF^F4fUI?^0ygtt=R+SD0beM+WyP9$>or2H=UTt(4HP|Zacfq#R}LJn-?7d?(c!uD z`G@-gB=U!$!=j%nkSaBb!!k#`eZF|+{qPhY#SJ|GV4sPQYuLqiZbJn^CfA)FD3+ML z@asNXLR=$#S~S*1=&Vn1|2D@!Y1Bg%eM?GruCt`Js(wf1&Sa&p!dHblxfxMmX;9 z$6M~-hHCPYmxSqqhgSs*>JEP}m6tS1kOF_Iw!?ugT6I5?w{M74>W{Z{<=NbjQQ;DJ zAh+l~dE7CNKtuRFJgo+Vkx|b_p=%P57Q#Kn(jiB#%c5>>mGn?7iE{GX=UYc8Mzk$! zu=b~@K39$fJEE_5KoY6kwYKWyz=eP<+wHF&NAtG3Laz7~ zznFX|P?r3vwENa{1Zt}J&O!Sl{noxh?FOLQ(!pv{jzkB3$z{?RH)d>foqDA_uY3|7 zN;T&;uSLOIJF4Zw9LWcEMTfs(VSTLDE4aGHa5=C zb99HIi3`9PEE;R525}b#g(~EyHQCFe2naxYO~t*^{-dEv!TMkpcX9NZhJhFhf|-Jo z1}o)*P$bl?q+EEU`*+@hlueP!00?r>`SI$~}pCW0S6iGe_I;DcOFYQn06#z7_q5VP{{@@Br#MhEJOq7u|(wITc_8S(KjT-Acic`b3;j^iTUo+qNuPL zT0S07Fnq={4lF#&fwdts!QHxo)!n9k`+n_#eC%6M*G%#=lI#3RnQr-N%S0K}Tlh$> zQ`(~`pSq$P;$@PZDy|A)7A6tmrwWdT#Jb0Q#uHnpFIy5;R6`khIG4M`0Y0B0lf9e8=IMfOFC-X0sr*@l7vU6^oo|!@^^& zrU$BZqMtn9&f&)He_I?_>Z<_$B$3`OJBf-Bfj|@4mtC?d~-0gdiNhcKIX+>nogfji>W%R^2p+x_sP=tuDF z%(Lo_#)CPdb1l*6b9PH~LVdCX)i(GgwOE3HiWT~d{4%vxWX+c3xR~i>x2{m*5=?ig zV4EntjpAwWm$I2l6IRTDg;~Sb3CYd$cQ;&8*?b&_LGjF^FZ~1J8YAZ2!_4q+by9e? zmuS{}Dr5%r_ipwh7od3I43}XP7#~AUh5?MLLiN8}^W}!^8V%P7cUg6<=X2R)Z=^A0 zB-gOh<=r@MM{uhTdmCPm_h71i6!+@fpH*bW`_C$p|4(OB;GXf(e|JW;wV}&-578Sd zo2#ctj=qRGptKBH{;&s?7Yj&cQ?2~B#3!}5FGkfA&i0!7D5*;o<`!JB<+XkM?8$PK zR=}tFA7=JVEauCcVR?{Y_vP@RJ2|BVfS<_eyWL}fDyt1t(5(ZRFL9AQjALJg%Q7}5 z#54^_T^&yi7bmsWIPJaSVW4eO(tp|d0;Qz?T5XG{!soQPM#S4i%voQ*f{vk>!tkm( z*OTQ(+OOUTzH$vL2$rxE3sf7I98VhA7+d6cIfk>d26s(aONcr5l-5@Uv8D`$DBxen(;GGK>|-*{6z2AWSiK+a zUk~C4DqzE?!>5<3bgt$~HM!*8uTDo_ANHV}$OEIN4Z1R$N{Ju_-khJ!npHNRf_aRh zL0cNm4B9VC%9w!w-$_Af%~KdDwFNicy`-8GNe$iXylvdK)6gQ>AArNj&BB<-Pz;uSd2;U zU;Z)^n!-KyJ=+^Li+nPAh^nmK(Gi$&qV{wBmq$*SnCA`l^}^XAu~+FX?U#Pu`qc$K zIm}}lLogeBX(f_x`sGy@QcN-Q=nmqoTNZ?jPU1kytlskf_HM{B;(>CoF0Hu#Bh~-fFuKR%AYQ;oWsQm#2&~IvX zmY24s)p8z2XWoLQRwLr4wnWDcJDY?SNO1aY*b&wJkw5HJGS*Io3HVBaw!=_XF#<6D zYwYiH7=M|M3O8Iorn4${v>9cjq2Z$*>B^BqcISWlzHEQNv=Uc9R^%uHLXf=;!sHOZYPQ4;n=k5SZSrKDD^bD2WVqpGe`JU)JA# z?1bw;tZHXkpApfuDuRQ*M0Jz&IQWaI5qUWF%dNp2%G_ey&smIBw;@u4AH5dFd#t0{ zne4#RDzwrZ@+9&k(%|c6*Iw@V@r4_yK6N;;ojH*}1Hl0D(>l5C*O2PATrBTUW#iA|Lo-1USJ5Pf!lxAH@3lU8y5 zqJ=1(*|*L0$Uyvxb@uZ1k3E%FD<LPV&yXhS4jLDh0b13ZjH^qkkoZ@iR4>jMijm>Z4 z2Lw!9!r7=I57Iy+s&Amr2{6s8MR zRQ1$Y4XBjnR{!km$sI;4=tNecb#V(`lhp&m91dZl>sIwLlLD_O5&))c#otCK;=4^S z)03(bN;6~(7HrVPa#^G)>@;ag!VZ9mfz#zV0gZpfn!3YIsSevUYz1zKSzsygcFmss z!~SSNpbH~g@iIg{c)R2$S9Q3d!l*?`YKJ9};P{5{`QtIHDdus>_l{p&xQK8<@AK}x zU2qmkPMGTaSg=v4F=-v0Z`7bF_ykbgkXh?O&k4u>QjJyjv=7!IKepM8rk`27Sq>!% zvRU!AgTJxjYgM$vie60l=!z+R+w61P2cAl^6MX|y_t}S2J-uZJ04CB!dj8c)!fvq8ibAQII2bN{bQd+HRl3h2%hpq zUun%QYJA5!#?H~Z0ZnTKuz#_P&h!1D_z7X$z?Yxs>Fi&f7rfoH_LiV~jyZwv(hwUHrk7eE& zD}}6_IN7^H)*<41XrcmW1R(=`4P(kcd=&_v3|lC^iuzN01rzyW6F(H=yX}b36|js( z4}r6P`19-v+_MWUI{Vq4>Dv~tK!V)<@*UV4B>dmuUijshCXq-*zQy{k4E80ivM=#3 zzJNaW64Hwq=ZQvHslur1brKOt!b9s5_qgI6(Rch=Z-~sHKs}gWY~~L z0j4Ah`y5Dq+TdK%T7jQ<6)R^O$K@w0slM|RzfSh;TdJq3vfhv{ffVX@t z>K4gJg(%R0goHrK457e192x!XI{c@c*2(XsT}u;Fu}u)%5O&Yq^i>Cg8 zUKB7=0IB?>Mv+Y_4_^jpXRCpPmBt&&t5~V3xm@Y>jAJ-8ZjoZC-Kd4L^#vl6jXd*P z-^rDla&@hphhCcjWJZzwLMA#!WO84~n)(N!1y$HV#atTpqt2ThSjQ;_V{&M-V3-8|VZ_IF|{-wf+y7>gL^>g)79Stl*I zY8#si+z4-&f-Er!cGEJHv=M`vBnPxJ_cUC~(2TI4+~%-_8_D&m7C$=u@HBL@l9Jnj zytir9s-g)ERVb1uJW0Q5#^FadZVPWk;Ttx zOu107vDnI2v~W}3nSTaZ9LJXXrO}5c zpkFP-Y<0uYD$lY3$0W6@ub#~@(SQ`|XeT!HB&ixFJ+qxdbg1v;yOL0CuDWUD1p@kL zKT^fs8aJ%Km!$-pZn|2`6&EUUziwNBx6o5oN(Um`u2~T-R}?Fg>l;jWVQw4}@~y1@ z=J|JB7M{)3IhbUmUR$Y~W1H!GB+2#fI$VJ2_p3M8a~?S(zA5diNTAdwvz7Xn*y{4Z zPhr>*DIGJyC0!U>1u?E3?6p9-q{US(#r${5rN)1+T!M3TMDmMtM1Pd?5R%XzMQxl> z6igB_(n8=&dn9v63~CbyH>s3Rqszhh2Y5r=JiVH}$7ENw@=6VUs*@1`1; zHObUbAbF#=Q{F6)chH^*m|sX{29qHBM32|0?2pJP1H1=#%QHnMn0g(LNDy#Es2RB8 z%&#l%UT{T&YR(lC7hREc3{;_>ZIJMThv6Qc7MO)nkWTkIJ|_+)JbxY#vtu9YM4if@ znbRwfu$}z5)J}Dn9?#m0*Ut(cMb%Ykg%i5xMP_viD$qwx1$z6xWd$1K&00*559a+F zZSGQx$|issO&C6#+lz3x>HlL8n_`(voPAra)jchv+8@v(-=cli5$}E>?aRd7{A7|f z+W4k_I%iE5C7GFB_qk(4CoW(#M7A5M05I?>^kBb_z@;HvI;-`_ws7>f=Y2n znkS%;*lwD0*XN-+{cJme!#jhSu0yRHHNfS&CBv5o>n|hgFB|z9EAygYu)cOGDTSAf z@i}`(VHaqsXdF$I8`s`2r>Uy^x0=R%Cm-tT{1KA_mR{|B81ki`NmlcT+c$39^sfc_#!;Oy~( zRe~Wa`8;ogDh`di9_e^YK8sWdb+|NJtLUyrsE^5p=}dnaR(aH0hut|^rnv*j@#CLM-OXInP?I|$4X=21 z+!6+^)UvEQ*YD*{ptMqX{jKXjXOx%5@~3fw%M4tU8a`1ZUjlSog0uJRI^p^k&~r78*x7daN141ES0B``cW28|T_y}d z*zmODcGTyvk^4pFyKc4KU!d{obmvhFdA? zI`QfPvhdqm1j8+!FHnQs$$xPdeC6he$gSf^42IMy6~8lV$vwmZapH z=Pi!hOs`2bTW8-#D0h9`c^8Nc-W3h?f9hg=6oTrthfAe6ws@L_-;K}#^7kvRd#dQ! zer%EC{v!iJlNX93(FG0oi8HF5%sn{Yk)NomM)cI7CM7OLKtMFsQSBu^)6W6hr1nP zAODmM6$~0!R2q1arQu=naFM2uhrkY97N&oYW6p^-wrSOS?)&l9klgMpfxgX%_0UAO z_KpNuO)3eQcNQS^&V#90SvUH>QK?@zpG*=|e4p-!o?C6f$4TX7>TNNeJdb)h1`NK5vIXI&U( z#|ioG`pfyHmg#C$Dk;rBm=G|D<0;v>kH<=s0w9mYsoXt3lM4F)Me_Ly@$>yo_8ks}?7Obcc#TfV||eE5+3wO_|TWR4diG%n3E}KW%$Zx1dY5L;}|OH>n|o6h(APtY7p( z;rZijElLkr94)qZ|76M166q`a=3KrrHd0tuIJRiLVzE5u);9}-TW^v79v*Yb$mGh* z0K$CdV)dZ9&m*5pX7@uwgxDMV-x1g`F zUK_?=4UYwRh&pP_`xS^@BjQ2!>*LfQ7W^E7M_cP({h&N^{E<~e;>z7@VQ8?EBf+bT zz7@y;Ml9-wq5KIg)&bU7QB=v!H~phfegQgjbk4b>EuAHr=$}}7?g{&iPxSAc(?2O* z2qGVrPe;48H?2y08R-wCs`HXW25TFwYC5qK51F`L;rau-Mqh-~OKyTy-?!^vY=x_3 zCywzANTeL6M%-nLllNRsvN3FI*ZcV>{kp=V*7_QdNAM*zV;xsBV7m84mN4TX{T_XZ zIiWMC>YmF|D@QP@#vi)r1>H#!)s38N{!9icJO?qt#KsRGFH7`U=svCEEaS^^qi392 z&e*Hy6-N{pbx3z*okPl!(v)BHXRWr~{iJR~&vyO5)mLQHSjI;%SMzG73$4hy^8*FCdSm%Jcv>=%MA339=EHr<|>N;{r!cf#<5vUmnr zqqB^TI@vLi*7>gcf=H^5$wDr>$F49proNh`dTcXX57-F99Ws^Hi27FK!KNKz!HT{; zV^`tY_X;y?7>&k+j7QS0NNN#1M7yqT=;8q@3z$Mjx|e^c%~1AY5bn$2@nQ+KGU$AW z6=@Y_X3GcmbkNr1UmG}x&wrxQE)V8csSHyL;mB~FOE|pE=@7(M8^@26 zJGL*gFJ2wCygbPxs#U@0#Bgvj5K}eEGov`$1z=w`tYT_gsa1sJ9jR1}rVCfPyH#-< z&q32C&AE=}9>m?uAWV;H_AI{H0LI8tKj+)V$0I~9FrYaC);+6os{g<+dB3#upGdR4 zrZ5mNM+O5mgnDckBaccnaj0vN)M+!D#8(SM_?9`m=lrhkoz#Z(L>_QX&V^9;TwP%+ z#+o-!!wpPqF`EX}H~z-sV38hyx-=5Z;Qq8z@Q57Pb2e0mZwpAt@KsOp=EFQaeER~&;JO_Lp| zX!ByP)JgA}05UPwh749pj#;5C_&r?o%rC0NDo&naVRJowR;XhMxq;d^AwiRmfA+(u zeoV%Gp6^j;2&O|C%4h$e`pq1``V9I6`R$_y(@ zQ9QinEi8JZLd2VMH&ICfcNNg2@MzLev-L4Bq6pHf5KYWVL~Q;R zpVILb_F(FEbAe}GEB5}VyMP}?ik_D2HgI8#Qr~Hj&}mqJ{d=d{-6gk{e_p$1!(D!~ z-lix@igRK1@sHqjKl;e5u#)R~hQrr-eo~90NovM(L=JQAd1t)fn_;x3M>C#JsrK@p z22Eio+o0*@{F^}&UjO$)ii2RSyZiSyMSmcd5d01r%D5ex<}Tk5OE}qn4~$Q+UJ|%; z*D^bq2BG?G?2op(^xnR%rVTsZYMxwm%l(?@sy&b~ zwUuM7L;I*JRv5t(!d9H4W$>$n%z9$v0w$r$5}dd_+uuV^7_X>ZHgr|rFll-(9ZXQ5 z-&xnL;)VUrdXI%Q@0b}|#|(GlO8=!=iP(#-BM>w;-95i*@}wk2+gEN!UN~(;w>DnYAIZH&Wu{~ zH*5RlZgfdhtA&y!MCaBU`F@Zc`tC}g{pnhoCwslt$sK8p`KpR0Gm9L=;=$$fUt?~w z%+3?DVy;A@m<3s=-D8p%u^R9EQ>xTsws<{$FrCSuN;GVPD@lt5El3NTer25sb;!ta zDk*?^tM*3eJ^`a#Fnudu(@C4uo0=;c&$YR|xvFPp=8zxE&aaS=$c#V&ZNH2vuraTHKtq@jAd8E z{6h<62%sXSYz2novGB+yExckP*u~4HU`u9q@hW@~L43L?LSTN&0x%6CI9UtG{(~ZU zY^D}y%x-a^bD%K;%okf@wn$g}V*@qX$7)DUwfok1jZW1E(6W>dNFMAYS5kr3fJr?> zePiYPtj~FYnNj}q39OrM+s^37t+9XzILNcQl51Tq2zLkB0I~ldFuqQxy$H%}47=Qx zEh@L>7-(z|COt)_BH@lf!*a&EaTYg1fS6HrYXV3?LrNT{#JMWzH(WQiMI$w_k>FK} z>o7{r7g!($jB@;z8ygvnJg=n~JU#Y`<4HWod{V*nBv!KWGJ{AWju~bt@*_KdosQ%G zn08ohenHL}E9#__-MH0jyLJz^-PUoGv;>ta&!n$Wxq2 zQKnx(W+P+{=Jn;WN$ML%^jd{4KN8v3jY}`GW8HpdfcfcI#YQ99*52@CQ${w3)z1;W zHFrn%9p#FT_sEdQ8bEHJDu2(x8c4|2#kh0CW&rOV-qcRA?-x2!c*y|>mVLTmVci@- z&cdJ<`*q5gbkcA==9A{bN2nho9MTws8^~k`KMn^MaW4YM3$|)^n*$(4DWQ9jA`QFssxyC8LsznH8awBGIo9UY%?f03s z`z{*_B_U2c(&SsZ;kmM2@9Z<*A$T3{YzZWC1L4y@=C}$@XpKZqrEzGFXbsZG9HvU* z2vRHD#UWflDplpKIrLJc&7n5Um0Z<5?K68d?`5y%rH*5ZSM!?0J{J(kZ~$mD7Pe{U zK$`}>U-8&0Pyn?S7r+60O@(J%)Bfldws&Wi!>ZrLi|$u-_6zhee#bSx9OAx>Ymt+@ zT(KWWu~}GU`yL~7)a2=b;r54^eNu~Rd+;>lojI$iD*HfAk>ypsF281`#b4}p7eiEv z?9j?9wh^xxc~<+omKmRa9SH#qnL{DVd|^ZOZ%Qrwr#X(O9)kQhsrt5d;Ba}4g!q^@ zN6G>e<*Vf zloap1@&B}T|KDouLSDd3x;mc)BZKt?yr$c>@@13iM3pLTy7Rvx(RMp`BbzVZ;u~RE zQeJ24=Om0qzy`O??IVFC;yv+5FVd}AgxS80Z9Rc&Dd0~RI7;30KN5c0@Q?ZQH%yHFB|K_TBr8Rzo0JIw@ zoZ8~Dwu6*JwLq@3ot7kDx>X`6f?;_9H0IJU$-ewvFDKMS@-3YGPDCv)?B?qG(|6zE zJ4GRbD406RhN$|OS};HSjqOR0m2gqVF7Q}ds-d44-L%ohK_5K+ZWt8i?eBwCEj%+N&WGsd;Zfs_#!&=6dV_)c(Gr$S($fS)Ci zb#J(AdYA%iMKkeF>6dv#ly!y3UYul?WamoQ^5LjhdaBdU@eb-{~I^ba2ZNoiR_-D+;Zq{V$s=YFR@agJE*J8 z)*1`h_?VEJVlL;IWQ?j7NOZyqzQmNvi`IL1<~%~)#x;a=`BNAulk$jdNvv+>5#|FA zVbhSkG1?-JqMk14U1mp`Q&e2aEmA>2=fiE?-2NwV9j2VyG2*uhT$ zO^&H3jio#7&`NMJ|N(I^}wpPFoEw_0yB#ziMSo&_)x*GRpb*kG!SNa_P)w6dQu5e|H(BNw$bV2rn4pdb z&}-+QDiBzOUp|9#I$gkSrA|h7{?STd3dYSr;Uztqu3T7nqa=FbKSmNwwCX-Q0~t|c z{*jQQb^6fG)eR@XFS?)oi?UOi#%X@RQx>6r&ssXU7%hgVEuFO9wFihK?I-uPU-`3c zwQ%bejuW*rXFUaVORu)tkc5RQv8wQw7@{>8pQ=~AES;@cH{*oZL>=?tsn1?t`F7z& zzCByNyMD0owg#BJCgKFfW%b{h$@LJpbiRcoesyWK)B1_X&h!iRK;8^hIY3oh5L|ST zD!gZ2Xfo|_AEkY=KSBr^<_E^I{y2E@wd8i<$PqoWJzVH|mJ-WlCgo(m#myl3nA3gq z^NCpBX?k3nnF{GUei@DM4dQ$VSje^)yf()!b*+)0AEI5?l74sSjcVR=0Qt>k6Ks|* z&c!CbXc8QHt|bl{v&!cqXWM;i8&YM?Ib5m90hXG%v;h_NfyOqxE+vvLfd7VLB3A2H z6mvywk?(m)Q%thB2)tGckVL32%YE=8(+E+fnvN6>SsLeSsbZ#JCVq6u!F^J6w!0!aW&oSN~rz#Z-ZS({Ra&mP)M z_lhR)EMXx|IjPLZm0IN4SoKO{3rdp;^`V}AD}iN4=_Kw$me`y8Wa!WAti#R|MU!Ws zFy@lautXVe5^Oi)V}l0oG?hf$s#LVr0wu}EJTxBBuyyArV{dnzb_oI=rA3YN9ME!x zJ^Ql>W2DqI?Vv6|)@REbie26!1n0^d<{!)3IyGN*c@yPCn$DRy|6O_Wj05o&e4e&$A)0WafSXA^b#M$9`Qb#Hx44UK5zQ%l3X}AN-K)6>m-Plue z@e2F$>?4p%Tk1@%CZqZwte-c zW@J@hu`-szOr_PqZW(8Zv8JCWP3P;5h>|1BV(iVrW__Ir46d#(U9%OMin}iRg?=&N zi%pmTp3sy#>-e^Sl&xSpWi#rzxl zC07@*lDd!mHQ&98H-s#~qUtFSBe*x_(;)+Fa%8JgmnpVLbnM5|ll3tX`HssrV2*z- z{&CaSGNDq4wQ}cNh}%(ah?`=yRdLQPU`7gFWCZmIqSpq)$!&DFES*5o@cfX{J@Pjp zK%-S*2cTdH=r--0_NVLU0lNswM$d%5J=@TheJ7}y{(}eMqV@o{f$hl4>D~Z&AAFb` zi(5j|C}^EsA@{8rK>26|2~wluI8bw{$)}rhLBsBj7m(>xi8PZ715J3}g~@A^V6{e_ zet--mxPpepa&bdLQvGQjp7*_FHgc|?omW-OLhykc&2&6+T!qr%Rz?+tU=hL3VOVRf zzaBa7uZJnUmv8BK(JZ^Ce!!FCaC+H)!kz4Da&8)cl@07(t%%*LDK7>qDH{~10}ly4 zTs7xKwiL`~9FJs6)X{{L9t0lq}xBPg=iP1v5va)}`TXtA$yr{2g&^+K__;h}CIpkhKrIc!~lKhdtT4b)a(bm9d;F zvr;=i9E?slEC^iLd;ZF-R|~Ej-x$uh@^uV!(Up-_Je%{PZ%(BYn|mMVUv^`+S$AXQ z`Hg;e#xqS)I|IGcy+TOEKP&I`5;bVZld%XTDHH1r++A-qiy_DP#eMZvU_Ia$Hv_-8 zQqcS_?#sU*(co>`{&y#0u2$E*{vmVt0npl&iKRrpKK!O>L~fn;G4!9g1~VYnz{t1N zMGNH}#)9bLiYI=&!AiwVZ_bXiWiwGVxUq^Ok;5k*in*V*(RvnrC{K8u2lwtcA(VfSrWI^f1J}88(hQEdMB) zW%$lQ=U0}Hu8R}RqeFKl9ELL{&Fn{a!&`3BQ_`E8L{d95u6_YiuX}iUUfkV{zmUt4 zG*X!UTHeI({x8x@ho{LCuYyRVsn~|-z}#GSqVmP$y98V#vsD1?ee=_?@`wK=-y6dXKBk$h4x#TNEDO! zPgl@NvPU?)8){AL9U}d2kd&gdQQ|nruKiiEZ*L5if->kSewA6T`j)UxCu)>OKU{;^ zzCJ`r2~|*|4HNs8R&^uazB@U<29=@Jfg3^Oa*%8Akb}a~+K{j^=vemiK;( zXO5zGZSW0O@ErUyaQ;d52QyT6X~$zm>mUE8VoGCC{@8jLBIh)ljg#4T6gW|x;UDGU z`x4X=!&c(3SjXWxwQx?+5BzKvx_eZ)ifq%BGSclhqQ$gxLdNR_A&pR-^+CtdhRF4g zh3X%(#hh!NyF*i!m2&U9S^n*UxH?hfDs7_J0dtj`x5?#^w$-HzgBNcLstCWl)05fK z+3`RkL2_`!uIl1!6gKG8DkKtYn}+nWCuCvIs)7cf4@W)~r^|TfsXjf=iI6+^1V~iO zY99YA@d`L%!|c@Wvr=HXSOCf8;O6Am1CS!6v!&hI*;klGz-(uw1ZTIx} zXL4h<-;%mj>qlZE+i<+pn83qG$kdxpk?Xj*jbx(e5e zogIX7A#5UIjDDf5MwUsOKxt@jAMgw<{sY(pCrU~1AFOQ$XDCIP;o}O_ylze~V`5Tr$(G+yRrOQ_^80gO+(t;wQcOd(U|NeNkj^OJK!Yx8{!$30;? zFG+Gc!rL4%j_I6FD7<_XIloe^QjHbTqlbo~u&)t^ zKjG zeB=+|hA|(YVyNFN!j`3_RR^bCyyphCRE<8U%H}=R>A_&U=F~x_o2T2u@KfmE$?UVr z5XuO`fG#1YGbFb%`>fI$%E;Y)I$)CoOSG%RayDqq@{Nz=FW<|)3eHo7DG=Ous*Qab zZRcO7c`3?Q&1xj(yN_w5+Io{F6*2v3a?}13UXRqCeVJON6ZyA_w#ww)jrgfdm5umT z#*^xq2W02{xJfxufgjHZB1Jwc8X``0T8weClTL%;``ZZ| z=tgJ#k@$W1UgpvDo>TYBvu?_J#Wm9{t;o`8X-Ch*p~cMl5^L)>(ZE>8Q8;-5_4x=0 z{XLXM^KLfSzOxSJn>?mq1%K*xZ~Hn%niC3oEtLHmG`k^2&V8+U&@0LE!T?=o*kWDh z?oG40&NgEPmDYuPL>Y1GmTib?PUb-uJ<>c{-+3G~&|i}sERMf|8uswLutg5s#V_S^ z;RSK3&lszISM**8P|}vBrjTV~AxvEK z(6D>_8Tr$NOwYNbD0YBP8m%&9TCq(vonItmX=(&#w|?WYb|WXCxTba$fq!#s5g6w> z9|6S{ibmrQI_ggJ#&r(2SAM?^E(FB3re{sL-Xk5!DZ0ohGNj65mUK_((8O8T!*mUe z%>&TBgGUh|VR~&K7GX4-qV4n^YHRq-?$GDJOQPL#+#`=g^ZSIi@tU+_a#n+5a z8DuPf_)PvtMMJtrBFj8OPO>B%@ifR<9K7DKSN!(VuHK$Vs`rFJz#!HN8mC=Zy@X;> z3Yma{p{)7eN8Miwp4J6DK$`!F+)os_@zS%#1~l+;r}f6vk~`GGX!RLl#v`XL3kY!`l@@`C3c=OOqlog})Bf6JkIw5{oB#NTuU7kek6~ z5zgFqPJ8?_$e_lIg8WBmO2FewWr^6%U;oI3CQXU5XVa&$(^_6h}K@j67F_1!$ zi!NO?&ix7B7BXlIdMZ4g7rvkKv1#z1ST^f~xJjP>lw*+ENb!v2gbIwLm3R2G$+V-p zk9+3TBY(WUm3fo(Vl|gacO^I}rf@w1t(kEg6@BeTGS&PNE+1rUJ%gn@qSI&p)=!sE zD5Vev=WpFO$_k(TThsjK-%$O3ctgwX)uXUNPX0RaG$;p&aC!yCvO@LYy(Ff0t=8JN z*mel3$xO#`rESy>pvktJ*JQ7peRq*Ht}A-i=6m*scfiwJnHE>lOvTU99FufDE5o*0 zcodWjwlX$H!K_7FKeQjherjI&(Kjh zAr-L11E=enzhMUTQdy~2?(oqF9YqA0zmTht-{If=Xr;ZxXO0BsW~u5L@ZpY+E^pOab^FDZ9LTxt=q5QpJbJ?GT+!q8br)mK$UU=)y<#{5Jq4?v zPKCl~%~zF%H46nDrZ(6P-#>SrYDPVCo=TF6p5aem5=<2nEuP{-4J2drm{8-JrS5Qk z|4!#_yX&V*`r~v40>)(a7%35>JhP}}W(_4iF-nD8pt2fM;E z`ocvviitPh@|RH_xcOFrIjrVrWV$k#>*`b&o2c$4yGbUD@}r=&LuE?9oqdw44l?dn zMEJH=$Hi!xc85+CHg#G(;p@w)H^OWijT^T}2-nE}di+v?0T3R+J@hul&ykrw$x?>$Se4oy!x95?U%O0mUC@0LMj zC19+@45H%Qsz>I6)Dr@;tGcsUG&}E{pULX)#@D>wjK9jUPRx5EqXxg(#Pf=Y=)d;{ z0c37&5O@Igti1V$ADhpgT-9rzW>P!-Ss<9=fwyZ@!K3Vww}$bv_YW$0NY}LI(?W8< zBT{*0b#}Po_ zJZ#@v@MOxHwAGi)^n~1`e<9U-KiCp2LM@e(7dMfo^siiZzlJ3<1(Re|p~Sm^QotdUspE zbgRP9>fLYua?GL!$?LJ!#&=vrCH5K51f7z#(3+q%BoaLm*@;yQlNsh4IMWPd8_Ka5 zMe;;x3Nq;W=;)B@;X6Z+l&Bzz_7IibmA5r)rH(KjY@p^DNU+Wa>qBjId!c4|i6}x` zE!z0*W34deB)h41GSNX2E-Q@Y4O!`@qnndNV_mRY_x!v>!QoE(;3d5RDe|9erZ^Bd z@i<+8j`m$I7w14^cQoJ(?9SeWNKy_<5L>QHpLkImWkgO4(O=P~q~O51!3ft^c{cuK z$6+VOiItMmxupv05@Lb|^b>|x#+;)&eef>mw3WJC_A8S;?ZYwi3t7zO$%3cP$xOWm z1rJOIFU~$`=fvSB6KtD7i#u%p>P#A|v_;}Ndob8s8vNkDPlI=Ta-Qw6+%Lq*W=>l2 zq9eIEKDqv5a;9jWv*3ig`;RYkqaOwZ)nRk9CH!TmxwkE(uqm#`FKC2YX*1k&jD9i3!Ute#sp8Xiy1*{~BG5d*u6G==#)Cs z@B40GoJU>|J>iwKq;SyXm*K;i!edRf-rJUb_)wrGSZID3H)Drx!NP(I^a)xfeK>ci z@n-taU+=jOb9S06HKq|=8GMl8F|gT6t|0^IA72`@Yd{kkGHZ`i-V%6`0WF|ei?MFS z5k8S$Z>ZIa{v!L@Wzp z`z_Zd&iO4#lE3_x_r?<)qx-e9iBYW$iP=zg+uy3dhQCNSo84Bphj z3ev75xjLX3rDLjigE*fR{(&<3%oSvOXbj`g#M%ZA`2lzOWsGgdbJ@w1uTI2|x2?Y>Es2ff)Y!p*#{zRx55z=j!;AUZ`1iO9_VI79yK1>~g5Y>g z@3fj)DwwJQM6M<^7>=W49%~Qo-rT_dTHoCHN6uWRAG1*R>s;_F$p-T5!*FR9cYv7P z+36hxo13Be*Y6e5Uafc?hCMV7*HNdQ%5P~D-JzhYUn?VV!mrAo}ljPi=ZeK^sDm2~bvxBN`#(cX0V%@-r_7U4%d90!!;v@f;K*j ze^RWn;h3Z!JBiU8KatIydUCCEm$r9blBV~+OTQnK|A*Xw|2ML6H6u=0>4Dl^Bf9UB zjDkxY_uNGWJx<*2?;YmdHi_`F6$XysrbICQ;{uJtbSvu@PRYl``7eP;X-!-dWjvVs_WOOKx6i0LCOz6ag%5FKDw6-QE|T4W^cO7p7zw zaKk}#V(k05!HoYA98SFa3l10fui@}m^#ySFihl)%7it@6HFtJY zYR}23d_7&%|Ie7avbDwbVbqd_n%5dF(5n;gkRqIE0KM0UJ1kjUAz-%XT6*i1bx$G4 zklFGhYEsLcgtAU->rVW<-5;5lix<~sM&aQ^&>OM6&M(DJvgyjbxQXTUo2|As)bvl) zcdb#jo$~?+O3$xskpga!Dh_B91nd0PihLg~G-in0U4cdMgE2B4?#}igbifaPk8H_? zOA0!Z-1^z0W@_9u!j43aPCq1D8c$UZH075aCDpmpsK+>=rvaBFJ{d(;DxIGpIc+{C z&`?vxs#g~n|JmPr`T1i2hi^4jr0yYJ026+2l)P#;HA%tPt5nQfz2mf#GUIs&9a7d1 znSJYR$XS_9MsC^s!g%Y^I?zu}QXMiu2FGODmyQk_rv;rr!+v_;vAQ96y(fC<+bbQ} zwtAp@xqNqaOEs?k?N>_9IxBqVlQV-`HzC8dIKjO0H7NYw)S#h5|9K5EsNtr|^exJ> zsr+{}D5y|(qN|lV05bC(>v_j&YphA~=bvt6%gU>?1SjUHUH3u|0m3di8?1XdlhG6w zO-9Q%MHJE=bo&Q|jSVqUn%EM>YWF+-2j+GXSuH9xKdq!JY<2VTD(Iki!+6%OY?Eo~ zA$Gh@Gs$+}|03_rw8}3c^t=ioMf4iUoU@~ z4LN|Foh0m}>sYPu9>tAC zx{>bh0zg|XuK)3v0W=&q7H>GP4m873<}3aTOGzYTXu$IUwZmg35C5H`+rQ(dQ}Ew- z)@8~MpbREI-L%e}KYsC!?K^E*4F5~u>e$goL)28aHEwK?^1t4=vFUP|WY(nArKh^s z0mQn~s(YZatfPK{0cGkzB^`&Q&hjJ+Tl0iSfhkC-22vKlr-t_X z`gFpRw6OIo9)R^&Q>@cemfb4}EHxzz00YLj`5Z0+KJ;pD`sTd$FRF+_%7yaG$b}pC zjb_fWS{e!mCB&OXA5;?Ib&%R}Tu^BYKKb&uBX_cJ`hj0?R+g)PUbSWSC#J>)x~_cpu(^my%eV2mm-0WFZlmT$ku1=?9+1!V0I0h;GNS(-KjM4& zd{THzXmBb4jB3#_KT-!F>nz1q+o6IGsHyt&Vr?1QpKsCDcP%lQUJ&F1UT9+%Q+#J$1XSGmkrS1TNy<2rG5=4&+zM^2midQ{4r^DN zVw_++-wZc5+UZ_>!ia!z(A+SC+B*)Mwh*8!im*z>anVX~;sCk1wf3sU1Q9!JrjH4f zd%XQ}3Vs4p7IG{yH+pE4g7TLrttV9)dIprp3;53X#`_ZGTt1PUkhBK7 zl_jq@t}F(N0~ELSg)#)o?h6%`oL-3nXf7#)=F(j+5wkarOcu#jE5p@~{1NLcVWd*I zQno02{YblckJ|U<=GGT++2qs4=)`|k*eTUsOk>n|@eK!!XuR4`?)y5^r8kCgt3R5_ zLIoFzAvIQ`gWMzQr-^585fRR#T@Em~>QBfObqTnlY8&|t^SayT)h3bjz~uLfO{BEL z*?}h-N+Rg69AY7J0jd4g)=Uw(@XgTK@P>(e%GvFKFZ~gv*$FUOKnYlXv8-|(!9{h! zu-Jc%>cT6t>~hq8Ii&MM7~u{{6-8LzgAlqnvDv3xC*~W18#JPbq#ST2rKvj1ZcJEi zjz9=>3yGDnGFjYn$WUv7$LO%0QWe01zkQeoc(4|m9VZSRJO-4@xy+kdosHp>o0gL@4Z2pBuM$OJWP@o&>^NBHltM6s2dneo z;lclCIw-t)dpf9hG>(1b)^yOml+KLEZ!&#mUD%*BP);d&{}FNpe@y+Sm)jIdyt}Y@{Ka{pL$}>s2stZe*p+2Mf*3 zA4#EZn_C8Wh5yt?E-vLSLAocY|gh%qow#x zt$30{HH0&Aw;Yg zRBms2NWa!4uurxo-l+7_yQ(0G5}&oE&{60e7tQ`Q+8sLWJy`NIrS#geKJ|3CMdl)W zFH2-aPKvq^Yb7$YqfE5-cOr6Xe9nfrkzU2lFV{hNLX@&jf^U*6u)<=(BcMNAsb zPXK;!J|Wo`k}xiM7XfBDGev!j`xPKn5}D_nI0RJ$#+}A9ODWY{e>Le9^i<6oz6xB5 z4q2F0s!M%$tZuDY82ks^a~Md43aG8q!eVD-9L7%wVfT6te`v2i`wliav?8V-(Qn`H zkmBfYPd`aCV4}itg2o1l>_7gj{^-|wNu^epwWQUlJqlpmG3k^xs?9NrJU$`eox$BC zw#(1!`kB6ml)qtq*Wq17X#=gsl6N;f+IVQq*?A>tliJtp)|JmwluSKIrz z1sUDTI(W6I+00v&^&gY|c14T79Xadj!c-GRhR4kwcd~bhj$$~v`By()P^r~z|1u9J zFF?7pu!zGh4mHvj#JXk{yo@s{vOxb zJRYW8fNr<(Sjh$4RDA+=#Qa{#D{5GjJluSiY1Ibu&|JQhUzpH|S39f^Dgt&14DDXO z9cN3B_OnndIacJa_SP5Ob);74VJ!o*=MG`P|H-g`C!SsbC56Af>NNb!xXJO_6BHmW z)+8#x&C^uDqO??)w_=QQt3_MLWs!X0zKvDsM8{-^rY{&4ZY;c5leH(LoL_fL@2p2T zzx|)@a{Om|kM+jn{XslAY})@_1T|?GGp)4#wy<7DixpJuSohBl;ZGblUf6@8#$uc_ z5SI>{HthK7)$Ol-+V$1O4X_p~E$YNf?@}N5K7yGyfSIB(a^~r5o3EIje`- zaxZs4>SN3m8!zlPzfnS2BImT++^sNV#aldFi;$=pg={=QTROPsxQ}-=*L$0mOVdV9 zfqBE@*OF|GaD#cnsbK|YARE!D$o;57DrVC`z2Rg1ftez9seLtCMXYS1@KYc4QP>|S`NXPYP;YUVU2W4UaJ zYH#lMA_hg^ePnFtk zKDbKl1A+fUsh#oqUnsSo2>oNF_W2mBQoH)*zffvN<$lpFIYLdU%>~+!QHwce|5+!X zQWkEOEd>8mbNPgunnRs0arWxMfT;<#~^N9%WU)q`Up)4xj!ODlkFZ?TV?ePK#? zZ!tfN^1Fi|3dYcqcmV#dYw~!B#KRPL|lJ>LO~p z;pcH-j76G|CGb*vi`m`pI9qKC@4bJrK;4Ln)8bG6#dDApU7XqL2#;1z#?|ij1{3#5 z(U>mi?a-=ve24;QSumoC1re^w*!V@>wBawh9{IKwx{4GeLdu7|PV!?Q8jH@2ZZK9| zz;vZ|T{6mACMDsV<0_F@#Vak9?ZyzgvPhZG>7Ej6AUY1v%gzT@6K5bN*QyRepGsSg z-WV}0#M}`rPh)#ji2kmVBX*#!7W%DHpwrb;t+3!+=^7}YJKwLe0Y7?v%i!4~S4)b&924qc&Z|?6s z;M0ENEVu*{;{{g~Km}Xp;(U8QJ3H0jylu)}VE>#Wb=DXB|9@bmOI+Z8hIK4avgu`K zq#B&ln$`iAVDE8*9@rOWOnOi20)PvaGfksh2_A2qLUwmCxYdPYA;PFJ;55CZ&?VaS z0(+f)T}rPY7@uab{n>yDpuDFqf2aU0UWWiLHXf~^C6Pdtlr`x~y~SQcIYlFZd9Hfd z?<|6{qB+2=5QQ0LaP+cxht;=>%(Z^oP`B*VU9_T+44NW)CkRqd;QTvb^!;P77+@a^ zk@saQkhWa9z3Xlrnt1znn-FS^%WY;22F^PhdbUT}G*)blwyTGa8H7`D>KUsz=BWGO zzW56qVBfz^4O^cK{iHdipo<+_Ze#$=smD8tLrXwcM2U5OQ`Q08RtLSweJG#ox=m9( z)zBs_<%eU;~;NyDGVUG6x z^g7AsDBpdjdSOaCZ&P%Gc5t)bZf}!IXwEOSWv9gyuPEuPQ{*4)1e>3hg-I`)0#bf( z{YFT8!=2wbs?Fc`q1f5y3&+mxyE7@ud8;U{!(n_TbXjRWH-?YSI`K?qZbB3QGw-J= zU;}l2ASA0drkdQ$ik$J>>$LYTS>cvA+*-xY5L>E^RPxO`$jF621pPWt2Z79 z!}4t*yhdt@(6?e`@V}*p{+7|d_!iA~-t`F$jbE}hpjqighEvJ~=XeXOKl7fOiDh;j^28|V<^z?w@sSPq~~Z@leO%F z;*L94Q9UwoEm^;Cr;Vg&wmJse7x7h0z0ddMNskJERxhayId8ts z^$NO}K74(FTkDtYmn_#sZms4FWXHn%tYX^c1nO57t<`_w4zzDFI#TYSFKyyB*Q>)F zO-=6$eWdq*<(0!^J|yCbYbGC|ObYPt&la6WCgBL3cXoGtVQr;2`f3=Hy_!MEE2^xD zf)1W5Isk{)y?TR$N9$K}TU|bA3^Mq$_|xcweF2+q?nsjA_`{1tnL5sLZ!7%sU`$5; z={LhvPuQIHhq zV}LK9zpnEbYK`iMJPLZZuJ-1h)T**0BY>C*EtM~!%YBC+&;ye|T2sq|1ahExEH3%( zFCK81cApWEK-@==BXZ{{)KTWZS-DC;#c4KXMUfrnIen~@IrGMO$mHL^&jL6p(=Iy9 zunAFmo#a`t^Hi}ue~R;w@aw{8D3y+IJarN>`0pgjOXVs6fjuS2R#*S|^uDb_4Etga zu{zqTI>e<_(rm=m5fFR{yyDZg)B(kS*|4V8%?_UaS+a@TTy@%H*c{y4*j)47To&6b z-TXtB$5)!NDd@OfIz1}ptG(&4vMIlL&t`=+t4^#nVxwhZj?^aB>4!k4^-645omhML z#_+(LJS^5}MH~7XoU~hs-L%5_vjG1_{cZS0ZVWqt&!hgJe{cOc#ng$dBf;O~&c9jT zr)#mBi(r!VX4B@P6P;6%VnmB(m|y3*i^{hKo?)BTskbwP-w(oCE|fZ~v`#BWU0Hwf z+7(t*45sv&u|CK+wKUOnYRTr6UY>RN21|mWE+-MJ^N_d|c#@P2_K}{lIf&PXoWg=ODsNqN1 z5q{k|T|qxGW3~Oo@sE(6PjCFYWlz|i_UA+nC+x~b!(GFXOq;oz(#$CzC;Z$TsO@V; zD_s-iC7n1@jQE(D8|M6tteH`Rm~4d@3ybqPtt{p8m|RQ?TtttE^jY1Mtk(C>GjD)EgYu-C zM$Men9vRT@U(>)F}uPSPe>wv9?_5j&vidB;UvM&gS&M zW$XPNi%3)U{mpVm-c3q9I~85}jBH5GUDc2Nxh0iWY713d%%nzY8`_Jg?GP0Qp<`TB z0z93Y!9nH3D=yY6e79c2N3OgFP22VC^udbKX$~DzT}&=r`}da;LX8U;Y=o-vy-ush zWJc<(Q2X%pHWd|p&J8`7tk*RNgSx#c{8ClvhS+G0X(J)WYEyi?x54<5dd=~ni%rXi z;gQ8_T#~XWqcw`T=y{&Uz=Nc0U0J+;aweE_H7GH@QH#VOm*Tk>uu?isq(kyRw#(f~ z-i3KSOoYxSl0TmXJRvrKr!nxDdk*X$Iw3rSsFBnfxzzXc#4_^&FR@p>cH@(ac0GH7 znh#MW*Cfk2Rpy@yrFf@4^$saP3XiMvn^o=eZH8UCsNmF6Q!wN~prHenp+pvaJ8UYB z^y9fmimtXjWY5QN&o2#~pAzrdmBIFcL(o?%u7l~kHl#TU5qs}RR5?| zjTmmy&T}NqJ?kXjEPu~ziNd)LGRC#91+5l2Ys#ytjNW|L;vm)w~jMycaG@x+c8zC1`~h9#!NBtE)8_qRXZkxF!FN z=vd9^YX(#C&USCg{;Y`I{jt(haL>M&!>=Q4us(vC`?q%;Z0EqtfHNKmW^atGCGKdz|(?rP(9lM+c_C_gt=Y z9y=I5wMujuv2^%_8Nua)UnMW^SDBRdbzQi0WsdUF`>#%=@vY&>YvpL4<)LvmDnHt1?e}l(v9*0ewx8yp#BG-2QcTE@ zV2YO3L~>h?1fNXwG{z?MG)4uzGS;XFP#8gu@W%|2^Vk*QhWM>q)UbD&?n z9@k%3f2U#LQwKYv8t;=!YWou+Lk|$~BqWnGon39$U8l0sT#a1%i5e5^3yldrx~5@Z zPoOW!NroSwG;WiU@(m+%yF&Kk1w^NFNjc?;sswRDXnzht^bcM!8d+6#h1a1kvb_xD zzu5uCfpbk=Z~s%5QigrqB2cdzr~181!_!|bnENI8OA2?~F0%-MYx5j!o7g%Bgy-o>k@!` z4Be+xWw~eI7T0*>$v<}=Rf<$^j3*=@f*cS+%rY!c()QVbzJUFFOqA6lq-gT5#D%f$ zYxfHUJH*P2ct`2rbXBcWt{K7DcsM^<=u>KZF8%S)EbZJiU^Fa<+H>3^+oiHa{ABn~uKW%!6$t9WPWFrrku>w=rdW^4A3j4cH z6EnXKtI5-LVRsFhs%xGJ*|kZ1!2b#RIn;37O(x!8o4(6Ul5UwrDrJ^jvzj(zdyr@L z!C{r}BQMhp2^ulh&At<}zBh@;yZG?flOyzVs$f8=74>7$S8Ioa+*U@gD+wFlEIA%T z3!W$pfv1izyJZxCMa(;GIsPC>QwFoA2Zf^c^rDDakSU~|s&0G*P1|Jw({>X)qKpPZ zV^~U6E3d|V3HnNuQ;%BktP``e$14j*g|M#+dUrymSy`sVz5h*EW5aa$=x^Q22NiCh zc5#Z$QWDyUR}+7Fjqjc-NZrdMg+ayB%PzVZg6{tAn!alz^X1`7YS(2^YY5SJ|3t&@ zWRhhfR;QCAh?C1##lJY8K7L0+{ER|`hrn%?W3d;rt7lZny5yhj3X7Y2^iOCzV^fgJ zo&;P(UzyE+nvuXG69{LG4P5y%Q<>D}(J`l$si^XNLe$`0hP(wHxxeN}1~5Ya^ie|q z+V9_+VkdlwJ=j)mr==B2jl?Wv%**)(86v9e+_4uw2qk|udywU|Bc>`Z-wod#Q;o#( zT&oje%GWNFJP~;kT)KJ~o~-Y9?$fNpDXJWotP1)Sk2&WQ1TD81`9@rRvdtWif9s;( z$qurU6hyY@d~xts3k|@S81aG%m(@bgBet=!O^t@^0#(-Pi}paMyk z?;ivWUeXn2zd}icS#l|ss3rICh}T&W`gHX0@=|Dc`EOIP2pP?t38Qk;6E2Y6mhfuc zfFNZ|3jN76d06E^%>~;U{r7I!)dpqD>@z`0oS}2J%_sQF8p;^yC&6oeEo=P=wH4it zi&Sl|DVB;Krhz@-!cUmr?@pL=^$dRteC{T}rd@-mv}WCO3z^*_n)&fnWUS$6tH>N&U}ihT&k|5IsR09hvES+c_S@>uTm`InLOPFSrQA6 zkAA&|J+gmjz6yncaiJDm7SFDay*R4!sL5rOuv)Tj5BAYvGge9{V^zk>ShY3RA6;;| z8%9P;a~c@apxYyw2rJ*KwKl#BnjKq4H`>hskAt}Rq@YFBz03Q7&Pb|T> z=*1T8VD3YhEfcf7yoiu=u&Sq<`691NY8ThyH*YW`|3}~?w*uX(?#gVO?IqKC!a(hD zcyai%!}jOwYqm1cWq&9W)gLX!%|rv_i^_HeU!>)&i~oDcrFq7GkX*iy3}B0EVzuls zxdZ~VFaoOuyJ!PK%6?hbueu92ZtLN3L6#TW^q6hvU2x; z9T9#Y$^4M(KhBLGe6Oqa>sr_?@$GqWT4=x2X=a=gOmr8VjTAexL5R)7F=Z+TO9tmYhXZ=B3%f$bLtCVtespNACDK$M zFJw$C?|;5CtGdGnGB&~%I{d&lxq1&q4L@(P$ANWU(PDxc4hg;z|5R{a7Q z>p*DxFWiiET?4^;Zf6niUsWHC5Vzj(bXP^2y=5YC%9)xlGQ??-{ev@E_YvF*a#5N0 zzjH&m7ADhH5QAl^2O!gjzFvqfw~_GMF4Z~IAMx-`BMGO~cV7Ji7`20S`Mx0`^3#OF zT&MTjQRtkAcI(n`R58{ASOJg9m>wQhFnC@+VW#o^2VWlqBl6f8n!hCO$gkfbkFzs8 zL0TF2p;c7g*4%&Z*fZR$YnIkUK%t&WV06?cvexZm~w0J5NARP4o9 zp2PZdty6m`(hN+NjISPk5CDety%^d9C&Df_OyNg6o$|;$+7a=g5GNU31IZ}-zR zqQo|HYbK*lA%*O^1`FJB>dnel&n#q3^nO?rWfN!U>iFX3$mGy9dcmy{>9*PIT-tdd z8L9SW_3Z4_((;!V_k6aoh!>kB@5`0C_N?68?=Eh4^q{yWx*F+07LyeQyi_)+CUuax_#hFX7Uy^SO`1WTuVOOV_sXz`VB{1&`9r`MHyy5%x?yxoYK z=amLU_3&Ut-n4|46!gqU=RF8|P zPqj9wUz&CHQ#yQzyxfL;;0mQlBU$zX)zUxaZcmTF^GA(Qzy7)JJWlKbSu4ik2=CA3 zP7?l90F)R6poFnW;~q2P42EGHG+4J=6Ow;?%>`8+>>k0=4c}CcjJJ6CfTDe}#T(`5iY>95 z)`iszhjzr~prmY~uqS*o_=WK7VN@Zk0t(?TuY$Fa~UJ&_r0V?F`-h5dP|a5-)vIuXz z__PjER({ZFO?=5`JOJWr7;J0+FTRfIbtJV-a{SIf9(oPtzXOt-;XD%{&=48-Zc^r? zICRW_$LC!JZ!jGY`-327l17_!ss~FJf3xp+toy!*AD*+7k!qlVZ;TnUcNni3(dtpR@oUb_v^GD`u?p zQS;7tVTN0i1~7MEVp5W=npHqO%%G0up{{chJ5Hk9<{(=#DftGjn~-B8Z$6Du}oHI+9pF^=77f`>QdUNe?k!L`nj)r#lJcOqp5mQO8@v+Ym!8*eB7fmi78U_=h&yi~;x26$WK51!f ztN|(Y8akye?+iF~ps1|K14JD3C}xQgFK}!JyMDz>FYAA_vqgP4hZ)6c?Vh=}bEEe^$nQ(lnidTeEIIr9z7Qxc+{w^Hh*QW<=V46!iKi(q%1Zru*5*qQD7Q zQ|3^E(>#!oyMdUIi9EqL0IW$?(rR4KCi~erSc|#1-!4Z-_?PGi@0(-(j`KM*iCgIH z#t?kICGQwem#x1!!wj@uCWi9nhV0J{<^#W3R?Rx}Mf%J||mf40jg&@|_|Kctc#^tt0TqG6xLGd@3^Zo(UROE`JR(j02p{?h{@eP`Sa)`#s5Fbc zi2qkdE}U^#TEvhut^K8^W07DMx3##@+RNjRS!V1-s!H2)x`>l5L_Avc87(gG-uF(@ zylm^R$dxAaT3oQ_sr>w*b)t4k{{>3}M_~m)Nh~sqx9>ZQ7?)8~w@99iQ}W+e7Yh8N1P6NoCNx{CLmJhqkjx z%r_7I^eXtWm+?%4goM;J{u7qbFVcA*%zxalg@u`1W0w>57<$|Q*&ii`?khX0nQm?L z<&H;_iJoL!eD(8t^Hm!Geh*!}+#Bv>mFW63G^V>+xL;8_dV|(o${*M{Dyi$p96waV zbvWgQ>#^jyU&f!IQF(^fE8Ur#`DMDj%WwS*>Um7>>a(tmH zgREG17Z#PyhCt)6-&XcPA}YC$Zk&+%XI7IWC0srH+oR5$j-?y)Q@Y)SqWUH`JM_Pr zbv9hQb6?aMgPCpN1NjxUeLIu6B4pMHriK+_)>_moYjoh8pR#WaQnDAATfTXaTVjhZ zVRr2JL>AX*#%~~sgDSge*X2gHR=h`|tDLRWdv)?!aQv4%7yPSG(t@e9g~b)0SfY4- zk3jsd_!rNwL<>?_ezemS4 zQ+FB+!V#Ud{@&5?Xu>kt8A=e7Zf74keSz>SiPVQHXAVlmU*KZ)+~0HR0Li)62-up( z<;VLEUiMtSNbs7#JQ}IGX~1>S;`A|T+-LqYa(?rr1^t?^XDH(htRTv2-2yzZS#uFm^$+MDaSiZ< zwtQ^qvLrHoJwE4Yq~wi*+}p$yvtxCSkJ2bCT!}V;1G~RA6{Z+yD~$Kg(&|X~QEic1 zw9~8l7PG>_emVFrnc{N$pN5TFUIe=zbD7Bbz&u14JyjV2AF=KrtiDh<`vy&cx`rzISYKev$K);d+C_*J#OJeG9IeTcsL@|&PXiQMOsHLP0tZtAFL%cQvIJc) zz;2pyMgzH)Gm>oJcR0SYY60Q$sG$ah>x?9e1gr8k)U$0;(kafjq;|Y)m)z!SOE+@P zn<}Paa9!Ae_@vBpm4cILo+?pj(YVM*-u`{jBG#hZ$AW2T+&fi$G?=&H(QkY`8c$#VS;L9La3o(Lw1T9qsHFu83~!1k&(MK?y8#ehNor|(?iut z;LXwvR#G=-E+nY*NN0@1sbmLhKAfjb7IFG?VJbz$iI^ddp!yz3$qhc)QPu%Pa)+s- zHgi8ngep04;q%qPql6n{uijk6$2JB%Tl1(0B2?rmY~Q(E6~_{H3&WN<9S3ttRh@X&k}C0@@=oT2|<+lVI>`DCioh0i0VulC#83L77x?KA8n^R+qtSmRT>ufJ0u(l*+M*#7)-VlBYy}xwd2dF#+%YpwcKEU{>GR7k;%ex?`&GotCj#yl_=+NfcSVIlT2@QjTbe5dlkExR5? zG02YDQ=f{<8ymj2m7{C=`Z&wR*PVXdiIYq+Pw=+vAS_1mX0VEvc(SP@mh{+)P3vYe6y|GuWniHWu7^>;%=otqbE#OthgIS93%|D71}+QBL7j zje?aQ)Ihnh+0{2G;jq9YcJ3e_*^3X?wllNiu1%_FB7J0D-2>>)i(u7<^Ru+0y-hxrt-Y8fg5l~`3-j~gO94AY7;{V6 zmw0!)@8>=~O_U(*Bz#8p08FbIqC@FFEQ=jJ76947?cCaKR8uELg!PM+;ni*#hQ;_` zQw_Y~QXm8B_n)=ZW<<_ca(;S4%B*sy&BktfM=(5byfX2JpoaaJ&73Y^81wNN#%r&f zOXCeB%O@WJ8Xhf*;1gNeOX}-p;_RZ~P1`dKF~{G=3+*We%i%kzMb-8?6l=G*gSGQ; z-l2+^2ss}}-gEHM&qjlRuVRNH`I(<;nvw%LFcKX0-+)lnp%%I~)`&zl(5VQQH3w*L`~%gVJE5iG~u zbbF@1(e+#m;vs@($NBX??i>7?$(RFB+LwUQ$IbFMcRug7b#vhz!O~RhX;G0t|LJEt z?>Kn~b;oS~&K=KG7p-b0fbuxc!OCjEx@rr~Yme1GL0N|s{1#K75YiCZaqTcogkLHez!VMT)0LZEIr}QQFu#Tx~2Jq;U}6p>Ysy_EH*U z6+Ykz?HCwc?*Fi~Zlmv9q-7y>t3+$Q&v!CzbZEO1T=&2&t=(Cj z6)LNn#fwl8s0hV`AE9Qy@F>t-@6NoHxE&rfc(|so%&$mr3oFY8yJ+ZuZCXZ%VennY z6)X0amN#(3CWE2n_j9QSRO!oC4=M>WYxVIT!06+OFLnB-1`%79>zl@tHtV=fZ;@*Tj(1B92K{|LX^{ z_Nl)KX7R*pP1>7l^iMw(`bpq*3`DVwIPX+xrOQvsg$KAF*d-6mvi}hdGOGSa4p!W_ zA+|eiJlP#L9Eyrsat`mRV2yqRgG2U)?kG5SAM)|8L*{`{^mm7(K_7Bw4I6NDt%XGG zOOlRSq>E_9@2JK^LqN8K@$o!A73c+tb`}H(5TAn`8{ZQX zzx|cSH>a%7{KaRHbVjYpPF716!I#a*aTWuynXE&DNtLTM?mKy^sSC`(N$gnc$}l4N zqTE<#|CNeJ5}9q0!v9g~_B7+7LQ>S!)kIvG*nbb1tO&#Rdi+ARiN1NYPRovWr}k^T zE#9uZ@KKNbyI%S@jcw%L`*je}D5HdM;myv3EhsB1vfqPCIwqsJ`s zD>^ryCVgT?aoMW9Xm%-?Aw2Q1Q;IP@{>b-exCZDjLB=}#?KCdzQZ*#Fpy$#zT(ipt+drp z-Xdpdsn4Nr7cTn-KBw&|C@P=c-xGAKEzCCWI&6`D^?OQk`t`J}7hCUK0egH*m70!x z5M^9UN_*YIV#sU>o5`{5%H*PacV%*elP&Iv(bZb1A>>7$A3&4M(pHyIJU>h06ICFg zZROQe#;r|rch{!NyKB>pQ17y9BV&|d+ZALKR6&A^l|)}`4gSTB-XP3<<8mH!v8va% z3`ovvJDgiwW@G|R6g;mE4xr3Q$=R7C8ccoabU&STv%P5XSlD@KRkYpJyB?g#YWqa1 z!e}W(ktYWmzy`BERG<>CExiR1adxM>PNnUy=JY;N7qq#zy}_NnubmaQk5)DMF-+=MW@GkG?4BrG5DR`lqW^ zwv%6zVWZHDAilJ9v=fZSNHbg@T~(}a{q-I+0OqOmcr^O3TGM!&Zyi|_X5&^=ox;|j8wiGI+diH27plkhj{ z*V+O~;QQ`eN0a?GpXm?O|K{NLrTgnoUbN>beO8K@9jR{=^2eL)buy~VRr&t$q80B@ z$@{V=2i2@-CkC#5E&42lTGS8Sfj%ZnuqZPMMBNkmOt_UZueCgd(v=+1v?%O5VAXgG zUAtCuf>QS@e;XHWsheu_uOtFhmVOHgqO`ZxMN4}I1cNeGQgYv5-tiWuBHDN>?YtAM zHAO%$fSk}L+Y$_rp#%d%sRR|POeh*tci1=5CSsk93$XX{SGmFTmS(;?wvhKtUQoeR zn!tK>;N5u{E6UX(ME80*Sx7wb`}&Ft2n8Y(E?RSl#X)ls<3VPN5Pb z&dhSCZHne+=?^N-N5&^#lyKsT75MC_Y%fCgAtGL|6Sn?_%JpW6Q>gB!B^Gd2LPrC! zC7$Hhh9?EhRFThD@=7q&bBfnxVHeXpp@EPbispj{Bd*$00b6fx3^x*rbm|WOTn01WP0_k$yHvo6H z3x+`&(5%)Q`kRSj(yJ6%9Df+2r0AySmhW_ zjPY*EpE}C?YzN1z3^-=0E~5M$!ff)*Yb&LnTJr3z(l)*w+w6b9=RAU%P;p!FUa)xD zH+7dpe%F+Dg5EPD)yPW}@rO|jvB?f-ewlV3qpoR&q^QUC+wR2DqNp(tXpF?62|BMV z91nssx6PIjXc?k9V3@&Xh&a^tsHOA`H(34Di}vRODj_?M>w1r&bsUpg2-^Rjtij)| zvpM;4sJ)ofmfeUv5Fu;d{G~B5t$g&Z$=??8wk_^hUG!Gh7h-_9VdV&`1umKYw;AmK z`!dwfaJ3CWh_I9kKOueGP01^crQ51}-;8xcPc6KDrM%grWk?wJ!Ly@=65uke=~J0IzwA23Ut_~}8teO>7rRjPwq!glO4 zMIwObc4Aa~<2^$CJiSeGu{)*j3N?Cwl0A4il26ms-W}E4fNnhw|49F^lGvt<6{lNl zQh&L_Zu$BG={nfFss@*1UYzFHFLk;Y-Fx0M__+)`pu%&2Z`po8YoPP-xcag%Ddim1 zR?`@{knB~N`1zAJTVCOAI8EQ!&ZW=5wayRmZ1*W!`-HyXg5kb6QNKn8421~R_Fz@| zI9KrNn&G;K;(}ouS_k2b(m@b^{W1FS*Zy;ixLw=WMH>EzediPXyG1HcBv*owux<&M z;f-JIXvWb6FqfXNfw8x}c{*n~q?by4a2Bjk6Ju(jryGmxJye2}xGy9o!(F z1B;WoqFMFNkgy;j-M}#vJJXrKI!WPgVbdZh<}W(+>8<1d>(4wt?b_d;y<@~isUuXd zYbJ8pp0ZzrF|dA;8(t@VfzJDwc>KqSQ0EY(>vAGJSFEY9y|*K%-rFNfDsP(%!{84c zBKBd=#hEYQsp*Q({qKvMJxf_6`?*l$rBE{qp=A22)D%YcsQ}&(T3j|AkXt;8JIJk3 zz@&HN%`vY6KWpzKTD@}18nNeC4}>T-L#G+wD;@fF`Z8$%$mcMWQ61dDc^At1c*+XD z+*nh9{WIVIS@Pa%CxSV{9l8Sr{-@l0sJG-+xrXVJQ|))io5pmNVwJt^;pO=PS9Z3V zRWzQIv)f7cuMDh|FlA}(?$FI*LqjltOvi&@7%ojY_8LuC@Fl*%tqu`a?vYT|Ex`A@ za>s|#vj+Dj7|^^24Hl?Ii90wsdA2j!?7)Zc`a@+QJGOJicS~1^;7NMk_hmvk zY)2l&Wo3VT-iU4eP2X6TLA>rcZ}x-@j`KNGTSVR!;sH8T{}D=DQ~9*2_MTt|vE^sh zTSPyq)yn3ChkWUpSI0PWLa}Y>|B<&rrXQ-KYycO0zy>-S9>gpbRK+_?7Z<~+5r9X#+3jZL-F7qc-G9T(n_fXN^RE96 zGtaxWTh=DJ^$?MwIPz)aC7J zDDUgDw?8V_*dA^5M~rrwU1B?zJR|e{we0riHi3ibk@Z*g_d5IuG)d99L~&&ktq>V9 z^FFZ&qshHe^@AZvZdK0N{;e=)qG~p8 zc6rP==Rjv448esX(gGyyLEEj$u1&8+}$6XzB6SVf|6db0O?i2+$?QpZ&T!cUww?91sXR@AtfNtCqIK#lA+C-#8i|b zsf%~wsuTn}L^#6*on;eOc7)?r z^m3Oc%LoW!kljfvzTJu3E*VeWZW#~f-^qC7P%@sTe@Di{f0kapjgiDs0L&OvC^IHf&ml=#%cnwd-c0TWR($XE`f$@bx*&E@CB>S+uz?KRV1TpB2Km0p)Jb5F# zGYxBEW!AK4G)^!Oer+6;t*)l65g z`xn}{&MEn`Fs~~u9AVvgYgtjd6+N-O!Teb&d$BGR5h#}mA8=70e4D`O;QOLFu*gLgePdST^mqvZ*lb(x?KI)D=BVRrETC7P~ zbe&^oCYLM%oK)h0a<;qr7_J}9t0RCjTQDLfkxP!&(ysJKNkey23mVbt-M%nBQZw%o zaL3$9Ej5pAmnxiabLwFi(U!*v)-Yvr9vG>-IIt71KeRc-h^+ksPk$nd+tOn~uA>*& zfV52X)uyR7*pWv;$sST`Z2cP(T!qZ|^g-#sTVx)>`Z_ls7}fR8{;uDNU3tx<9u~pc zMqpe@swo$}2|*Wz?6Qm-u7>4Y)Km7GyG7)5o4`%QH}qdrv(-jG7*6SZq5#+eYxG9h?es7F3YmRIeKkp)QtY$HhjJ=LbE$B|X1t{7SIx>F13E&VEtIlC;`EkGy~u znqemV9LNk>t1RpikN1(0p1tYAO6JrV+xEp@4V=hy`$SQ)z~00F@%C=*L+SWoBb6tr z5WJ7+CkR?udFQ-Ha~tYWZhO1dy&Q$dSF(FfUnybXp7}bDJbU?btDAbF|Mm~z5am$p z;&*LCIDvah&9DGxLd%pWA(@i$e;t|9KlP}x-q`b(LQ>vT(=l8UQ~Crdxd1r~*h8~-9uV^;LsD8h}pB@+hE563mdE^Pg*)oMVF z0oAU{pFre2p)Z76>hfC4{R`&(J)GpX)-N}L_|Cz*e>4V`T>Kgl{PA2!(&nNv5%Z|nqCU^1>o?-g%io8D=lJkK%)(F zYmY#VBAn);J~$q9-)bh#8(hw=H(L;nXu?A6)*@(fQednl;0BJSy9v^CtKw<89ptiJ z>#(`;u3y8Y+%0HMMc&_k@gI_t+E+I-F0I<6BsWGW_vD3Fp1q~nevtf~pyA=8Jiw;c z$d9sgic%@|wpROch@Qk9Mo5~_nnr3FACu1ODS7(APBu2>jJ;R0b|lz#}ihktK(4_l+Vhml{M`X_6pUro)AmUSZD%|0Tf zX$(!{gVQBk_&W<#0#2GOi*RgPk7eW2Xf>zqGZX(Q7#YsO5Z5TrZ-D9&z)~(KrPD!t ztJUvL%EE%aYGPDETr?4~+vWyDgAW;YfLqK9D0{$_fY@3%PP_OMt;X9|BV1qG5Z5c9 z$Mj(oOzw!9T?9AnF^afGP5#@=5Cw+q=@b~%_#5UIzTi8r*g##`HP$r7FcCX)>Phf* z;Q4iuN4qYj!kiQhO$q`^6%lM%{}F4(xn(S{&fclc=~Rx^ek==jz9Dd`}A>Anr z(k+N|cYkvc3hsL!-*bP@_x^i-;j#BzbIdvBHLf_%b6g|aYqEeKN{cprF46S~4DZiN z>ABY2!*7tbwbXVu0?sGP`;GEXx^FE{$$pu0{mgG8EeQR`jQ$5B`l6g#^F|M4!@fg4|1IDRM!0iVZ={0_Q=cfZD z%T;f{zVqIIc$>7!ghf5udaB7=S2i>F$SEhOg6i|fL)8bSTxsBBDax0iKGjD|AqMH` zFNnV})UPHYIFi~AiJW*=bZI+5owaT%8$Zg)%#pd&Z^RwIalFWD%e9+#iANyYm9C~( z+Zs}@v6%Smx_=u~l4^!f-k{N9$-IjapMZJT>M4=wW8;6OcKFgh|e%37W;xkCBN?V0|=ZZ5mX8=s8jzw0^nfQ;oILV`$^2f zhnB7~j!&>xi{)}tY#Z*U5}!4ghV$5BhG63vhpTF9}4xH>n z{(BEQ_2nM+5Ld)YU{ofr5vmbBkeNRla-?-Tzdv#HnZPCkmar!OHjsEXzyvztpY%0;zubHL+b7Wy5~ojQ&YS(&L625lb|^Km%y;atNNETon6{V>={F{^ zGUCE1Co@X8V;(1VK|0}_KH_=&kG>=S>%N51L@!d)JDF^8jU}|IL0Z_`ZVNE#rkrma zpBy)%@|>FV*e_}s-kd@#M=mGct9F~@jqZ_f3ltn1b5lP7)Yi*F=h_CMIl{73pKl<1 zizGVcmp<2y1K`x)gkT-V!`HKJ&+NBa<|IuqJR-=_TG!fO+n{RwqBwy4TPrm4S3$dZRhUnM~a?RC8sE)~!XWyPRxDf4IrR?qXgm_)@7 zB5wP_e+u=JP6+Owy9pu%T9XZ}civgr>-yvnX(t`SN- z=m8TqKHQL#HhH;G?@z~6*inh(m^PgaF)ahSDC`+7`W1o6$gcZ5D?32wLqfk?0l8*M|KN`io$47BOJM7J z`^~NIzTCP~M*DC#T_mu%iht}g-xBnkH3V$CU5>t;WH zj3Zx&=cc{kxpT4|3&Z&`#crR&Y{`z0u8l>8FhH*hW5ez?o89BXrNOmYg~P7>?|p{@ zZAY2T_R!ZFy|zLtFEZq0ChS~wC(LrH?#cXI(n>Tge63PBo$IP*+-8(^vw49EX-0pM zPfz+2bJrC3+`6fAI){gmWd4`%a6S^_-xzM^!T%rNFe*{_)mpjYG&Xtw`iP?`i{5* z*x3Szc&`{Nhr6S{YlF`7LncqmIbjU zbDuoxeSJ)LhfCG`oA%HYQ!*!`;7?f3h=*?Y#86#IG*A@Bohpk#Zq^urE;C?^Gv_1r z<<1X9HAD?acTuOVE`5y$91o*+OBEVzyC?zSAW0Zz&XD2^>L~73N?O&jk4EdYYaRGF z3d4PhaQyG0xce-Jmigoc#Y*p@=nH%moSFBta>zTOLJeB_UMlBo5BC$Q zDy_X{U%198p(+_hRaVtO0# zNP@QTB<^l=L;WTA9xe{A>DcN`D^}M7mZ=p@)I}Uggl+R)=MVcB8;KG4q(# z2{~}QEqHQ-9O_61Sj%_)4yQFACFCgHB9bkJdXPr>tk8Aw0mqN7vS3aTL32eJM$>cw z)M-I%xPSSA~9TZH>I7%66oOsytLToHa948_E6jHTg1bLTlxnz0Mk zagSh}#SE|=7M45xYn}3LYg!Rgc%?KKg>v}tW?8^a^O6D>zF&DEE5p8#i!+WPDp z_$CGD)4d)HYc4mq+6ed>*dj4!xK>(po` zo4LO7!UP;bHmKY80c$fqx3)=}K7}DQWD6JW7KLY|Q*Gan{c~XL*W?Ls6-e#h-V&7@ zg;h+bfbM}eP)XRT*w`=(T?(aasd$PyKg*A>bzBDB)uugB-fQa?tU{|p%-LYs&FKDQ zDk6k9QXS(s#O>rnoF}9JS-XYQ6rItZ!+9w|nknL?>9( zBYceI6v40}ZL$1CFZbuQPajcEadaRjh)lUu;ckS>@)`9ZV;nanJdqbLOtnxn-5B64!pyhnp3cUyOJ-*Cf;yM1=#oZOH7yw z!4juNLA^)h=^k_?{n9?7zfTgm!1BEwXr4BkHBKUcyaoGD5_W%17ZEx9J(F}X5y&B+d0DglbGel&zIJ+ zd0{P21m&r{O)+nddCbWt&)IDXmNl>IPmY#vy}kQXUED~+;qg58UKy2AQ~~z8pK(Sy z6VigjHCt_n$c)I=YwUNS<3`^G&`*>WsuBH^^S_7Uk-i*OmYy40DgB;MUq(pe%!dDm zIDFG9rT|v-2l+CK59*#-3U9=?vc1Vfj?;q`*Ef<|0`H8RRqjZCtMtQl{~$VY8*7+) z)&g5OIB#>&%kh!(=R*Ax-Q|}!-L(}l*)?0rk=0uoc|j>->+l4n+xJ?68g*RZzm^$e7gBa@%VpA@^onYAc zw}aVLhh-AnnZ?5py>@Bxf4-E%A43@D(xl zDGpo`O5fKSgkwACm?YZ*sygaG4rjbzz=)HOwf0Y@B-LoKoTA_7_ew^#s-;KY5gDe{ znRH>(DcE-COU-`l;JAN0UEw<}5;BBzocB}*NyC|DQvfN=$Qf_lZsGwbBTCY7Py$$U9EhtnY{U@!wsEO*8|V9>rbqE}fYgLmTE?(aF(Idj)jXu7{-CVI zsw%8!t?{3iTk`+xPR~}&L0P3~3Wl$HZYezeT(L!*Iu^;eMV?^y@z=aG3tBKPo~h34 zuzaic2d3ay>4lkYU!yP=GD5YIQtXnwU&|r>kI z(U+k0HRFRA#xmTgVnROf!E7!**jn<;EdwjuXjWHN*pytYJ9JVKQTkX#A~}II53*;O z@Jih5?*p+p<~%m_K8t7RZZ#KzM=vah+z??Q!wgubA^H9~K`x@%vrc(~Q%XSKF8U|m${vuw=hyyGJ z^!_?I*d(aR;p4q4(aV!d4SHFjnxbPfDAOK)9FNUNq_YGl-y)WH5C#7g;T@Uba&dN? z@O&%Pp^gMGrOM7FZDJ%Vmib!`@Lv!@mOBVblY(1kXeALviT1=%dfvV6w&sfM%Grc1 zb+XB@Yi{tX^T0We+2flTrlvmsl!Z%=diod4@ca#5S`G1~k^k_et+d3SLs~>`x}b^+ z7o~)Dg|4_^4b2E67lYm1&TUpi3_^}jltL$f#(a|^D>Y%st4E7^u1{Z`w zW?dcy@yXC8XPnkYUnBjFHxzU?mAs|Vhj#udR z^@qF+`?s+euy?dmNJocC2H?;f0f*)RwRU3oyk?H8u{4$;Tjs*Cs-{AGL%H~S2EeoC zY{eI2uf7TL7X9nJJkDKf@$myGqjXvGgCsc3yCH0l1#nQ|A^#?G`|z3F#~#Rgt$h=k zyAkCcQ%=dmYOQt>?Hpydb@ODvNQT&cD-#!sd{t?w`aZlzbn(IB=~i#uE7!5J*Xd_> z6{yLYaMmm|lQ=KDdPV5@&=IRP-P-B0ag9EI-1(ODg*)GcHS-jf7~5?yNonoo7-|w< zC?g*Ekkwn324&TflX-W00YeSWYZ}G zyravl%rr+5@0x2l?h_#;sOHieh6P?0>Gm`Vt3o>zbe5CNam3IJdqG^|*8;>aDR>9( zeCPlRu^W>(?3DndZVqJI(YL;&shvEiqxs{o57En<=N#t)L&TUqvSO#?D=eneN$&~| z7bl1f(>ajISwgEDg8OoM3;dL6ffV90+;le&p`o5+^D>j_#b}7Wl@wK;WL^4%?Ke=| zPU+VxwDvuT?ALK$QD+xgyn2knu3e1~A{(Y9 z{z=So8Mt*%Erox0>GK2G`&k8MI{_WIwGy)-*3C1J= z4R|V6%sqHHl=-gaU2d@1%fh=Bv&Is*qXNvzv?sAoGWqh1v#Q)69mD3wf3Y$ZXaHF%C^tLN%4X}6Jh#$+0uH*t>+*D6`Xrib>3?Pf3aX?fK&SF^?Sfcw`9aal9kRx-?Bn#A& zb+)8ZD$b693%H*5&k8A220a`SCt=@t3e$I@s-Uy6yoEfV?BTOQN)??cuW(}ybT0nI zzSKUPSL$VI4l7PRhhLYt?rYxLQ3esnCI38cf0RTH5bE|xI8qOcCz|(==|YjCZ&13U3O6V%tJ~n^T%w{Ia-GtB_dms&eNzv zlabI4mUSsDtjAh(zz=;TBrTg=8~f-7lj%Gg`ii9^_{oGt9kh3ro&=EPIJ_b28*}g< zJJViy(oExkt4Rec7g>6b#N{v(LT6l^l8Ti_%N!5ky`(0k$0v6OzZ0d2I*5Q`TbZH` z2Nown$XTNfb(hpo^%N|v+{VsSR!*B~PVh9z=zwXXcXwG1)y($91)PWlD{^^iRbtt4 z_ZpmAmd43TRgLiFtsR!;(y2MYAZ|Iy~egqqBN-J6MCX<2n8}ae_yfZ22;t zu@6RqD|^=%nK`2lzb@uGC8ZMw#^ynSt#R@|CfazDLrC5La3&67>)q1e?t zq$Ly}gbh)Agow+Ws91=B1zrO#|lo#gZ!X`EDR=$?$J*jbdlZF_@N!sE=$nv{( z+h?k0gic60-157f#xs3O?YX#ywGWH;h7(3-WKh%$<1~RlN)4u5m=Bv~BPN;dzN$`e zcuL-1&qKw29BtO(j!fc&g+_4W-c|EI$H8Bf%GE}3zYIwaVL@C-25w`*4oX2wLSc6~ z>pZppu&F`RH@indAM-xfGDVF`vlHMJsI*p*7`Iz495LZyr0c?HBG73zVB#lb(DhLI z<4@P$;U;uLlpEiA)?7AL%;$UJg<;$iKv4i2xC66t&d%~dUZBeJ6jqoezZoi6`J9SwhKD^ zwO;jLca3JPmJ8+=v{g`!J5LQ>7y-UI;yzkmV14w))SE|ye^tW!OfYuzKk2}yxtI>; zrN^b)X0BqG;^^}KoyEvupJy>->je?dI;9s;Xgkhh+wW|D2|8e_{dN`Wtp{nw&~%c5 zF8VM<^y^U7RSM5m^Ix^Yt&*!F+Bh@PJYuTCT&LP=)#YgXolX6&BPJC{>?)4KG8K}m=yW6GRSt`{rxo$jY2ADKP*f-9!mjhz1fuhm4xji|-pUw$ zIs_$xp9kxiMk7*q`>yAHF0>yuPP5unARLX#Eg0EgGUcZ_F!l*u%4hvXv0=1+j6GED1nH%T>$KF82_biS!j+O~~X#pk;+wZM99RmDWj z(Z~=QW8-ozI)mPx}n2=Zp;7yE-kpzSO9aqCgNtNsN{D5IPg6O4yIrnM@7IaT@1D1 zb#aP?RXXxT58<;+BL(5X9ur`Gi63o_1Kq2=LdIFL&?hJDd6SVDp63p9cU)hFO=R*# z-hlOEqTAdWhfK6@I}*l0|qpjuP+9=X@$R^Yu)7(l(o_OwrVUe zDQ(h9^-gJlF6*0=DzL48yBWlJQq~AWq?;BxjxRaW+xUl1v>q=LYJHVmc8>yluetNU zo3GfqwhAgT*_#tnF|g(Eyi1$g4rs^ktjS323!v=M+3F1}+tT`(K8;IT zh!nEUfYU-{k^)i)cPx27#EH=LmB{3}`a}<55P^9;WTDLZENcr9KX; z5`3|`IiVrus_I6%zT|?oE4TwcF<5`P9JaLF>@Fex*RK%If7M^Lm}}df9QooAhETpt zlfV0i<2_vV66HZi!PlJu#)U?S6X$c?d8U^tbJ~gj?{>l|jwCgaJ^!!39VXoQ+h@TS#FzcyRJLeN;2p zqg|ynP37zFoWJaOA*CUB5KoIN>sS#9kYzAU--=TQ0)%Fb-I*=TR&DK0qsSW za=>$$?k}UnkQutLd*ccH0dCZtFwPWdbi8RsU>@Y_14&&fcI@qupuAqExcpqKyfD}a z`RtHyhmFj`@~1mluTvq2W~n%jL?Q}7IRh}}ix%1RpNl@z{+E!ZecUrz7I|BT#1_wO z2)Ji*D)yDr6cQ^hrn6!%r+TS@&w`sjE0jeRX9Zej_#sF}liChE|GGQHKm2qn+#}W> zeK~!~;v|1bXVdAOzrvBa!HMnoXT|sBgMM>-g*_kC$#@tu`g)Rya|5&}jNYXB51m6r zTa-X;(Yw^P@+xJHPVjXVRdn3Va?N3QUoR7@5P+!0XqrOd8$XZIgF>`=R>G5H1c=71 z7XTsI5Mrw_@#3Cp1ez&sb9d3%eITV<3UvoE!2ZT9N!E{Lh(dAk7TDqqp}wKT$~0Yf z{Pso+v^6TP9^v&xc{8C@Q`-%SE2%87bW2})HlsnrJy^=%WvRWyHObaSj5=$!U~pCA z=)n_vDnK2>tjru~sB`a#6i-)tHIEHV)E;7B3j4719x^+FhzbJHEVi+0$*8az1S09` z2$Z>-K#8bZqiKy(BVl40DSF1(^)PE&d~|VXXGc!2gRhX*+#?&4uF)0#%$Qu6hInrw~hyaKA|+>^3{&h-Z>AYKeb07K(>G{sbL zXNrowoQ(Le($RrP+=OqIk!j&8Fr=?wv0d!)Xtz+YL+qLWA1G^Ut9}k|F6>xU zO{IariKJC^Lv3bnC6Brbg(S-}_7UgYY3h7Y`R9a@j8 zk?P!0yn-vI+u*A(yZfIW*~A)9BLh$OBSK$_EobZG`vozA(1uUB2>-rJ`_lWT$l36ufP9h_7OUwj}!%wJA@=mOHoG9Ds-34Y@S-f;1%^ zURPD^Ut1jv^E=(1?W%bDd;X~1JbJbKPWJp5q@6iL)6B!81xm7O8CYXcb;VO(c zF9=505M`8D0Vqj9cv1{VtKgpq8zl+(3j#mfKx|!A%#AFYwGC|yiaeBGWSJN6NjJ@O z9BlolVvRb}lxWLr|GvtAB7nen!0vV`;bGrnQSS({Fy)t-= ztQe?QD??pM^j}1_3SGdsg6cjHpyKdl&ZxfFYjzD0O$oZP@g-S5t?m^yyxn2_M55}> zwHf9QwQs1oQFDsS_lgp8)h-Z)p5|mR0{Y4)am0a7ipG2mCt5+2E!B~KOtvi7LXbP( zDt1!6tooajh0WJ~>82&+FZCItG|BRfX`}RlULV5CPI^~HNhSt|<)Wk+>z_Ogyb%ZH zf(4+c-Wk+f=dJ2Z5R6-t7j`HDkhn2aUOhLN<-&j_!)tz{axe%i$O{A@S4Ds*A9!!H zJF(~(&&H*NhVy^pOg%VBI7$%w%;k+mr*uOHLVkyh2+q4(U5r#r6--l=PQ2*<7JHsi zQSuF8nvpZ2aC*-v0DwUTa@>pVU?w@5Qj;Wd?F%!bj(>51oK53N$pZrvReR@eLekCO zk@V1Szge1EK(>dJDOeB!ErREtLvXm$t=n7}2eskOFg9;n_<5><1t_hv&f^;34unn+ z7TllE=?Xv?+lQFdKKbV1l-Va@pe%47pyxG+JI@2;~C-6tS6QVUW+@Wk!-7nyxN zL#@xK2695aZTD-jEM4=gae=@?sNw-p^zNGsS@WIe@0u===O+@07m#Dz#gy6oJ!Ruq z|2AbnxW;(Un>aB3DpX6%KrKYUkHt1Y|lT_kB>i1nt1I>3wsW%cgy$CnLk9sJnx z+sbeZ+>;j`KYVY3L#__>yAC8vTbqB1Cl^7&JOBHh0Mn$7D4&tmO4}pMdyN}E-J3ky z_1Oof)x=OBY;PvG*vgT`KtY2#FUjkF-64a zzl|xio7ZAW_P@lGA=X-HAf6~~jLQ?`onw5Z$QKyjVH0BM2iZ{qnMq64cW`;2gG3fk z+ZAHPvM&&lZkk8h&{Ce{&^~g;vtv9M=1e)Z1bauO`1K$)vRk?-m_b{UHS#cgksmqJ zbSf;mp(tc_K%`NsX_v1~7WW)`>b3fwVifKYh#4J(p)FPXTEX5me-!6Bz=V7#skKP- zMSbtxu{FsZB(s$&=bheB`gMap(3pu;Jnoy^ij}*|9ONH$zY05zD(8@B(x_Zu*4r#S zh1B)n!51TWw$`1}&-==mw31(6_bTPXb@k7HcsL+JkbBLssGmEQL-d?NQW3DXv-(@! zufmXgN1R~ytv-K~a5Y*3lX(ajxlsKZ;war^QcctYB-LtUuL2NKUKeBY@4%TqWklnO zoEyZkRwLb-m<^8~lR7#pR%_jtGsIE+mKMhJF;@CLlm4q+;bPN`rC4iPJ%XkZ-U)Iw z{NIi{)(ZuWc<%3D0sALd{CIAktzsE_+a>U3k)k@31rR&soofgl;@-CtO{kNNu5mhd zt~i~1&I?ZG*G*1`)Z2+JjO97b3KW(SD*)}v_=*E#DlYIzBw_`V86k26MR*c7Y|#Re z4mtR)yYnw20Xm0WDkzUd>l}{mx~nhPB%H&z;rEah7+^&Gxzf#WbRu}HogPY&p^p~X zl60r2H@HfZC_b$MtvZL&|?%`}j;g zR|0sI!P5t=tv86ACDUm#5iqippk2*#Tu71~nuNtq#3Fy#byt4zxsgsH*3#g&H-`qy zQ9Di!w3me>R@V#QA+nL;QoAu&fcR&d#PK`+rC!88eTj=H;~oBM%2s{;ZOW8}d~RdC z?Ms(PZ}YicAZ;5D{-n{9lNTle_slM z0u-z8-S^j@sw3G3F=nuuRpD-u<*p%W_%61^-A=g%()R4R2^dBxs?=Ujh;$~M+1`BF zcIZyc-myRD;xi^^D#N6UpTw%bwJ1EjM!a)#bqn_Eyg)1aeb3&(H3io&nv6~1LTR*X zf#vLEuiAmqk(!1{uLY`-XI?|?xx$o|5r{% z-2<+~QoY7@VFlN^2n}#x7sOq0xdal6;>0e7B{BM|M=IcIK%I z`lEO0?usHWj~+GUqAGr#RQ7eZGH&!kGqLE*W(ka}c+Il_bw31%@m5d{1WP}!0iuQq z*Z`N&4xu>{A`nR0 zx0dekFb3MJnYT%-rk$LrFzOs<6y3>u($>rZl zfP^qE3>ho~pc*57OD+mj{uhAB^Z}p@83NUAVRJo85x%b=fvuN$h3-JKNWDu)CzQi6 zfC_4h@$c;X-y=w?aO~}+OXTiLW_)pG-?!YjsnJ#tOH{RTyY97&tzionfcchO=je$R9u`T{lpc3Hx5x^;5GLAB zT%vfq-{v8bguOS(=Q#fF!m6y8Skmt(`=4XEE@IBK|nofC=#g9&ys8Yah zH@(**HepOdrh2W+z9gT+Gy8;53dr12@A-dL`@#@sniSk8#0KNhB4j*!$2fZ#jAw? zY=@bU-A|f%jecGh03-(h7L@>kACz7M_kAf6I+a?42>*UVa3HAoqwdMFt&vucZ~~zr z@EOm&%hH=k;45x%O}m8UTb#{9tm#HRN7&B5Y3pHZXew z$O8rsPTw{^Bm~f~qETkwran-H2UAe&k~>)v+;Cav9$yZu1$<5j&7Lr;-X<4BiU7e@C1hlJKjfTuxg{4-6!dPw?xq+5L z>$vcn#TQm;p0(x4!8a*=C9eX_l@%@3B^;L6J8WFTv{k#85>cYc8P@p$@h=udC_Rn` zk*WU)UHLEI&Z^i=(K({-*meFX(>7nhW?X`Y-qm zk3T38D3$7QT`t9kVO6kMfJkgV5rn%r**bM=X^_bc5j-G~T_gZK zd+%K4^sz1B9FF^JO8jy3Wl=0MkfPxzppPOz(?E)vbY!69$zpKh1GswJC4T=3+L7kW zlP*Yog!r(o@@)bWq&})+I>*3pg@6huowT9m5Z<8l)oX4glS)})9iwV0QJo%OX{b>< zup77P66`zh${*|*%t z@!q!F?@erywhlEUw5ZBu;@h_@H5fB!99kfw;!&3G*}U~^gPIk`I^OQ&iPutS>vj%mUT4mlP=Fujko0+5GKem%tHNQ z^2J{nCwYLqlQOwidhL5!s>uH{i~CzrKC3V*Te#Yrx9tU<=HZrLee>MXy1|b?}3Q?m&;)_ z(ciA5zcd6ddx$jF2t6={2=*y=0AN_&w$vX6t=v33N&WrQTZJ2fTy?a61E#zfmY?^D zw?lmK6MJQ1w}I=!;&lo1yj*;MZ{sNbl(JqnoyRa4Pxp8DlZ1r7Hl5>XO{q@lZ9m72 z!iRrRJO5Uqp{Wk}q{T)i1JW1!{X!1-tee5W>na#HKleSb{Gh!7# zLq@m$`j1dFcQtylG^M9BW0;;tzpZg-h!JF>H*FXIcx7RhWtV5URms<}CoWa>X4N>3Us47Sacbyfz67M4QVG`l8`w+RvSaO84H`V z6E0(6z8NJb%V@naytUwTy0UKsUy<>G!{a1%yTIspp}2MoKoaeH4Zr$Of-x8XQ?U|w z_&(USqpYjZ3ZCs(KpWg;v5w4voCCd&Fw(qN`&wx+V!%=u0N5k)?T|sY45V|U2GbEA zr4MHNbt86sHc47-jzr*+ES<5rX+=2?S_(l>eXiFcqfR$6_$ZjC5WjcC{L_@{W$6s)uVJa) zL&bBo<4A?2Ldg6p|wQ==)CgH`l7qRIYv0{`=M@p4)2_xG=> z_>ON>eX~91q*KBS_mAjAX{nN)*spoPi05(Sigy|+;f3%{N6LQ%zJKSPP!i5#E1${# z93#9t{2L=&X?uGu8@@#z{ym|Fi2jF24j3L_-K|IZj9PbIp>B2k82IknmW5(I+GX2FM+nG_xuOHHil zV^^qN(O!kEL4E?R0+&^1m88~7MgjOFSC}TtPF8;=>vd-UyKUl&0`2Y3eQ{ zdCq3Rd-7WohFfw0_{%lSpyk^v2#=u1Rik84)$_nPKHgXeYVdni3AuKK1#O-dag z)4m{k)&PP*G>fu_Ogm!zC&Wx`k&$#dN%KVmk>C+YMaB#8utoJe&;|%)zhExPTrp1v zTpU*xp71ka03%|Su6qUi(KLsR{j65LI>)Uz<_`$+SgI4!X|B)3OY)>kLEbW{n1daN zF-Rj&dQm0Q>z-#lAk?#R(|jKZWG_#=CJ{m~EaDZ+#`BlzNQ7;Ccbf{7U* zn|Ch#5!2779AXX@Ah5PId0a|WZJD@EBt)kcHS-h#9j`XGRL|e~wHkQ)LXM&KxecXW zB$Pj32JZ*!PDg)Ozz@dhw~IuXOR}EdfG3aOL_N>D9Q}_~R&II5h>jv0Rz!Pr9HL9kY zrZCL-@Y0q`PfDulFu_6?(A(}(=L{(4H1EP~$Q^u&cn@x0e-N$92Wfx6+E=U)@eYog zTyj!NRfpwyN>x$W?I5Z10X8;JnNzAt%lv69)0lTq2IL+HKxkOMeSATHhAkr_tEOy% zOs-TTt%0b68z}4>`njCxiBRzQ^fW{EjUeYGR8^KC({;*vwgZz87)-zb(YV64&a>=% z7+`!ou@*@s=I{u_9y7ESc~{IqU?-@;ECL{5O-xY6Ay(csz9&eO=`q;>;X1YiDjk5G zhfA^$`P?AfTWaN?B7oDku%}v2t%@oOJ=0EOydF?7rW0%X*yZ-Lr(mMT^yt9V+_`NI zf5Zi;>oZUHMS;=5F!+mb*ykEtd_Yz!ton8(3kS^1?hTV4^UA3 zzTp4c@7CnFtbdrAjaMvvb~>(<4(vX3stUV&a6|+#qMh`-(dFf%u-B9<4bYJ$H0H)Lmpr;E=(`1ZI#| zNQ>kAF6hbieeCkpX4dLdVmwxaZ-Hp_V6W(Kw1_`f%~PmO2;dF6B)9>cBbzPRGSX*9 zz4^6soU%Hr7z^0=aiPK}OCWmXmk-EU;se%TZQ(_z?V7Eoc|$Hm{S3aBqJA+^zeRD{p4N<><)f z34BNgT*c)VZfO4fg^B6HdkyoUD?6kiMZChDGciA4&QBN01|MkR0?z{0Hrusz1D2@l z?*L z-#@-qAMs}c_0c-l55Iu=qi!q_sbX1$lbUx%FWxDNj!W~lYQ2P*2>lpDZjr$-t@#zZ zODQ8DkT>F7uE_J~*Lnr+uQ~mnPoF|uM5O|L2K@C<@oDra@WXV5=^yIv56rFjST6zb z&+#Z-ZQ70jLXH@cGLxdJYdD@6P=4tu*)Nokfggagf3X3aoJxkD_5L1>YSp@4iOB>g zBN*(lP*IVc&{Ih1%)p+fg%4W4W#qF))D#3S4lRx7Xem zhVM^f4@1ic@s}0UB3!w4sCV$Ge?Yba(C`-&B>z5~+79v#5n`zhMIsDdmp1I4_%>imGC#P|6D*$Ge-iBEF=6dvlY zBqS$atD;b;eFOfXaiy!K7ZL*WrFjfmvs-an+q-F|$=O1~y;2bb91edB%4(a&~rFeYQsCbiCwrI_Pw|ceX!B=5%_{9KS}E zb9PjH*0nJIet!b^|Gd@jY;x?jj#rNkR`!;TQnBWcOeUuszU|l@GM3qY-}z!Px#M_{ zzc*T3Ia#$jep0oX96@Hedb0a{f|sk9VB)QH!MNSo&f3|=+S!uR@fQK=feBL!JqbP1 z&bhIfIWI=W@k#ft6nihb>b-f=Gkfdf<6gYe4Er^KLoO@vt%24@ zm?GYIjvKN9f#donN%XKxv9AKjl!s41oo};t7k(UokCtMNHrIE+N8IM(hUp`w_73~I zy(c7`dnZ4dfqOU26RR-SFei^yYHJHAsxLOv?3uRcTFvtHcevEtyh;}D}| zto;EOtMi3E(?eohT0;x!W6{F`bV5HPo8`W_9+~*`**o+L?%$-mMMX1@a(6cfCsMqW zC4y%Zt+#dpwoJ!>+GGjQ22<=DEB7IuoG=*=ZJ7C!lUKBv3}KGJv=|ZrKhI_sYj#y;_(bNB=VU< z6~UxZVXS=kvwJsS3fj*z(HVyUyYd(5?bJng8H6Ni5^UG>Va3jAyu3a|6CB*l`7=EWP5nsO=X&n;9jHMu^i?zhAL1${iij8#mc3uChUUylZHp$%Gp- zQ85!0!iWkoX=aZ6UTrn91|Iivlz4)oW%dGg26{L2x%eXkTe#E*IL)h^>~MHmQDJ(_ zv&eiABQe^(1da?T&K7(TV@9TLy=oO@#qav)32Ie-Odk##+RNNIDP7ZReHSE7G!9yO zlHv>wzr!V2L?{=*+%KkFHg3)*=d`3-{;e%l92EbY?g%V1#TX0S+<8QO7C*kxj6?La$(6Q?bh#0LNkT0?z)j1f2F{qeaEKL=Rri3;$LQ_-4rT?XL20LvRL;4>wA-= zXm#C(N2&g0^BtQD@#a_!UaRx`#D>Ptk6v37<28X*Zi2y;0^?nkgRS+666zlzlTu z1A$q`Tk-W=FbcCAj`i*sl5v}ESvwZ)jZvqhtg3VAob>YlAaz>WUXPaC%ZW92S_vKH zJ)NN5vr1fDwb|R(OI;;%!U-vg;Ozp$ZU)yoAl?}h%8F|Y4RUXW=xL5U3cPzNK`pe;-j_tkd(w+|GODcYx zTuijtU`9jp+`OPRrkQEFw8uJt+7T67tm_x12CF|@MR#Fc^sg79ax5ua=rRjw=rSGf z7Nqsw=|b8WiElkM@nVZUGd9Z%eynosQ0^6&$_?K(qAS?UYy|#um2N9*GlfD6bY)u# z2Pst-p2|o{X2jJB3M=}&m380Ys}Eb2lqHF0^K_X}Z}VEKd^ih^)dEl6{qKQ;C8_Dn zF7Fo}HENxdl_uB!TFeaNc}xaRxeqPy*etP8ZO;cuBv(fjSctdiD8 zna-aktga2Hd03IErfNmFB_X|24RfPrF*{g3#<7`+d7V#_^VRWy@XIFYj?X6n{#Igy zIBxWoaYlOlw@X`-T1M4-(ylN{E6;nrEAge;zr)%>MI+^KyV|Hn$VcFK#u>OjPp zPp6R!Ju_R$^?C<(@MMo{M!n(*;y-n~RkI6Z-|*-by3Om?#lxPpH&(b+^o4Gjleo}* zuw8}Ql1C$|O1X<>v@l+(J?~EM>sZ#*K|Ft98DknzYSuPnB{BIhH4!$Q;@Lh>fqNth zfHoy$MNDw3QAaoPSu+S20WUhcaQg{1G_AiCcAb<_j#hoNeJVu%Hv5FnromnWVXKKB9ZMbi%(U7a&D9DTiMJnvBS8$nWvNP~MRgkw6J z6C#YhL+q=Z0(69)(DEgc+n=~gqNi6_>e7qq(|K>+mru^7ZB^bfu-dg_bp!AgcE=aq zVtl6S#PaJ;wFAdr%cM>PaOKU-(`_?m&WLi4WIzNm!@N%>S2xzY!XF9X1#=X};+Sjb zS%yIh2BQ`LW%7%w8scgl6r;mCsWQd@R*U~D@JO^aeWF9z9lB+d0 zu5G24IkZ;RylNt!x3&7NB&0va&~pL{l*cY_8m-!<`bdJ&(s-}q+4)4nO4?7Y`##FD zTrTcV(Be&0Se&TD6&wuUBrPop&3qHc3=Wyx6m)+g{!|}QKWB$A}o$p#;``GHa>H|zUX6C z6#vHtgUZRfci0U3P+jT?iwg4ETMKXp{~yZUI;_dIj~`Y-5J5tuQ>3IDq)P+|2|*g^ z4hM{G38h6krInEGj?n|@7)XvB&44j@hd$oV{rryKdmQik4{SSj?b@#EJiqaY^DJsP zrzmKfO}=(Fzt->5hT+2WqTBDu4IFHZXI^Mzie0W2+vwCckzdTapMATm^C zu$%y!vodF=N}1DB!uu@IYf0U6=~k@vaQX;Kd&T)aMTns6rmjzGRBU3ci-OQ?rU*Aj zWeSX%@8>XVTcH;~FhaL=ki`!5nq2kwWmu7w5DgG~n>Iq+Z_|dO7;P&Qf#I8eI+mrC z#3{^KVP0uvlzS+uCcCx5i`Ogga(D3x;VP>0S);cp&xfYb|E?XY1?WI2XIN|Z{cBhH zvhVM?1s@DP&~K;;3Gq64;7 zo8*;(FFsZv7hm0fXkPP3zVQ8IhSlbVdM|^uWK2AfIA~;N3~&WBiv#Rly(Sierslwj z7@#H}O}~K>XzUjNe%DeEPuA0Yu92OX^UvWfF_#zUD$x81e^lKa0`Iz9jp&1ANp_kb z6o6NXs=XAoKa>3AUC&=fHB~!zhaD5)y z#xr?k22W4(dr*%_sf2j zcvDjFnfEHC_$gV_-ojG@Y^Xuvm^aM`Ck$&EkCx4hufLNgcWa4Ke{`h+aYNg3a|5vY zbd7+l9*EZHn#10L<#3*lf$rBZF1q_JZ2vBTyIB||lU@{lc&%$0*VH+B}ZWV#@m zk;68rziWDR#L(p{!`jO2?Z@`ohSX?bZ*;88P+bp4S>s$&`ZAvN+X3EVjYOmB$46cZ z6oYdKry9~&-?VeLc?&AHZCl^yh!)PAjfgqsxmjN|y!)G$jG9Pc(OtP~DKYV~_j+^M z_BDb!W!HW;qiV4VnRK*R!K{^`JC=9~Vt{$wuH`$?CCk`}x}HWSX$0bUfBQht6@pQ;Jr0Jg_ZDLKwDQJmlj6~B4bGFeH%HT&D+$# zg_hiOL43>sgJflHmc?>K`xBu<%qoJ31o)%Ms1H*>pG|y%15+?DJ3?K_uk4o>y`ZkS zQ%fvO;i~t09RE4XlpT4e%S~jdoU@t!g*#JUMa=%xtNR)cBU2*}wKp=R&dt=b1PlC? zx?<%0=aP|c%?qREvyNuBycf;_X!SCAp*0(_^MH-N$s|3*^Ce5)*U~TYO+hN04%k$@ zw!Z_k`?0MoK6&rJ9{$#_K7IHk3LE%hQ6$Jy>qA*G-#K$sl{TwJmck8lU7LvNp&9eUz0{ zM`@|~kRK-uOoe|I2n{n^gf)ke`U=%0)Dq1TIzF>1+~p-*3=_POMIa9VS(34?M&BVz z6K2L>iQ=Y>4-{|pjzK*5l9Hirs#yn$^VmeGIt89MgS1W3IWbVou}skqs)qzHqd1sE z6c7F~?C};1o&1;pX61;GjZW)pNt$1bUS)a@55$E7BQGLz>{g5zuJRVRD(hw((OEZ+ zR0@;_JguIsHgg#Ns7jCJRGaxQx?#TFc(HZGKAcqU*AjeSv5A=89!vZ*V65_D9o6Zf zI#AVl;weYAfoSNvlT9z95Ci6Kurqx_a0I9SkBVpjHK5>6nGZyj`9q#8yj)i>p&mn? zsea^Df2ilw3CHrt>f7u9%*eXCdE2J>a7BCHp5fDL^)rqudVf770C3QBBy7X5to$;zOS@_)U@q& zi{a@riR29mXr*phvWQ6om5Q~ky?P$|&10p;R%^qz;Z3pi@}7gO{9A~h24Wn!c)Q)u zND;D8mlrf-AHn4QCY%z}1;H`omc@f#mV_LBEuACYA)%j+d3orZGxlFzM0&x@h2d%} zX_vbO;dgneStSm>N*iU99y}TO^oZ4+jdKv=vEWP0CAVE|!$&wW3+VK}WXFA^XnzH- zbw%LLp^=#-(0L~bjFpr#ayt@JdM?XcSi0TE4cF(}6HBTy&#JP@3hv=LxWK#gF_!Fk zhVG1}it)-{D&ih%ppw*m#Rz!JwBKtgM<__UFwR?pv&L)A>o{rYo71wJPBHmh@0n>G zRnrV--JEj_I5dB1tHx+Afc#rBy@H(-2xs#xX}CcKxEX6HCXkSpdQ_t`4%D6<6DSS2 zgadqso!5Bk+d%Dozq<_z&rRfy#k8r4iU#Yo#;Gsk$>apm$+?~1IW#a}MNgLw)8&(9n7*W4^d&6Hbu z_xM8hFJ}8dg%Z@WU!pTY-6x{#A_t2O$wO@-Prcz~Eg;Ls8#b(d_(p9)HxiKRrosI4 zW8^0kK5XNlvQ_?;gK?M4fHf}#$M9hgXNa51y#nj@^(r&)ITuu84te_s&IPT8o;r%s zUZ&R?d+tW~#n{#visVGZjdp*IJI)-Hn`L-HFBLp$dE3&ty*tZj=%4dT)`F@>FVE#hE2?m~%&z_v-VXqB1EE&wN28*{mG$-&d@rxmVZ z(pUtm=q%1=9C|zIBTSDmH7vs~sxVC%9~K z1iKxz}OdPvOY8IedgsFJ|#kJg~(qn zAR#n-N?^k`eC4Fl(0NLr3H)`DP>njS!ui&c*XXv^69MGhtNlQP^}V5k>7p4PX%R2U3uczK z{p7Ut(KH|01taFD0<)L-uPvV0idZ)gjD7I{MXrHy3icmqPel4VhNmnGP(<7P(CE^* zuH}qfhVoOPYd;^`;Y{XeqlvD#F{`gG_@MJY*vqg@O2vNa9EDkyqIHB$b2Pi5CLeDz zMc_I2n@2J1MxQGc zp&myI+p}UtbX5!6OVY>jPA&Fkz881ZkubOrY=v)gTOF&oMDLgLy4_6D=g+7O^s_7Y z>+Mh~c+bH(I56Ew!kdUYYp|OL^j?)1yn4{NA2pnl)K*@HO6Z#ITF;w)Fb;kXQ5Cc( zjnIO&m}f+Y1$I??r+QIg*bi!_gx4iBMZYKI$V5x2Vo$C_OG-h{a(Z|bEpqT^UZwbg zLv*8^`3oA~rhVuLU}oqlvGG{n{l@%`?UkQWejWLT)Upd)d6nic^|#aJbPWz1b;I`W zWtSrgpA0dn#fKC8=Q!nRL(w@2FjLmHb&cypa#zOl9(4ixA-ry**IKP zj4yz`ygy<-l|V6Cwio9UV3lD|o9a?U=BVlVXy@mT5ls_Izk#uPE59NP7%9pK@%YjZ zp>pHL?tf4mjMwSrKHFu-!jmP0zp67f_FEEuNok7`{yH&Si?}l=AHe7y?e7s$7(O-k z&CAwyU}9=E({CNZdi#ZNF0~7tRL`~np zc=g5IB?^uzmZFM%c6|)03XKWKQ@gz9u_)qSyRZqklg1|?*2?k^xBILg?Cnp0{6k>s1{O;IuX^a(hJ>ps}a zGZ$nfgGzY4dLbDf%~dNo5e<`Gu#%fi=S)X zD_Vi`KP6c^@LBlnr`I-^mpPTz>e_0o&L+RItXsX{^=R!GEFNt~E#957$0o7lH*?bi zU4S0?A6~%W8#gE9=^5%ku~A;9*6@0mN2Wy&c+VrK|J56d7M{+o|Q4TloYmO98 zLYEEOQ1&NGv5B=04%Q~26f;9-@@hk=P|D2+o+aN$B$1nJ$BP`Eq8n}VTk$;je)*0bT~0UeWy2>1gPz>wV6k&&9~Xs3@SV%BW>oQh5M^Ec2eFB=kaI z=Hv)vrQlZ=%5#@|8Ai1CtqoXG&kWHbLn{JETeYe3-*)qA<3m!yk_M})<|~G@dL+}1 zsISLUxcLN-P1B7@3En4JC*6Q8p*79Q4{)PrMeOwE=M0+nx!uPb?$;9xdEx@#L=EZV zdbLeqee3B>YJH<3r2=+s%dkTp*Ad9H**1!MuZR=P=(6_Cpc48h%>Qqk_S5V7|018p zY>fxFrOr9lsgM5k{bCDQlM6*+3nQ{+GA#vfq2x@37tLvEFZgXp*{S^?hJ2lODbU7z)RB`N> zxZ_Qm;k%z(bxYck8?l~oS3f#wNz#cUTf7fnd_@`>svhuw1_!$fFQVYTfH8Vl9tU_e zjv1Y}0RMG88u%Ook2sWhsP{cd8(9W-{q+u3f(n=LY7Mv-uJ`btd}|QW8Ti#k6`Px) z7tM%8kEdGvs3pm7hiuXRbn#W-EjRG-&d1LtsDa(wjQ_P1CW2gkK>Btr!i0ktt3N$YNIz% zTH*1N3g*eHpTz~~Hj@TA}wxh8dZv8z^i@t^l;99@^epB z8QF>Nu+5ZMiDNw6(FOPNvVrvsz?Um_$=8-Rh?w zOv%Pd`})HEXRnTJ=@8z1)1h?UP|ZfWthfqib6Y!B0p&}wG&ka%>3j(hgF)K25nU+A zX$}`vRbL3o=*{&~Lw2n;I2q#e9To^D%2t{fiXdbV@qMcc&fJpQ*T%|1n{qQD9t-08 z&pd>Q=1zHwr|S=W&NKHPow!UX_-hz8{;Kbe@6Ys%>fIN^%l|aUPc}_g;eEV6zGtAK zM7|$?ofzgPP5#%|!F#ljLwuJ%+~<`Q`Te_f$pS)4Uaem_>lS{P&i|PDX2hI662Xd- z`b6iu)HsgyoFr;}#9DF6IfxZpbJctBpTGovxE`mtR%d6)R93J|{tM%S=;G6dGL-Zu z>=MVgKNk7gM?`B|0=`o6>`}x#`h$m|SgiQg&S0HhoFQ5^X8|-bOd|eW7I}Lb6vA(7 zThgvXWnK~x-{b8tx7=6(vRkDQ`aRx1Jdo#V!yWH)mOSPImXGrS;YLc%bl+1-40v_O zHMQK8)uGF&#xrwxK3?3ZXXiLnc)53l(D=O+jh)Vk&D;l~WL+IV!rhIl1mgN8A3v@V zOglZc)@yJH59_Gu*l%&ot$9SGqQLwYK7al}f#v%Bza#dQ?C!S-y)BWSW;^MB_?X|^ z-IHq!&aFYI{vpha*`mYcV;QV79uq}{b_9?I8l@Wri<&{aw>-yvS0k~1hqq;! zF*YU{)L(vP3^F{kyIek{o9$9;sARYiawqp4`>zk>j}=%+mOooLs3gziy3{77w>{V% zCfN=8Ry3_1$5o`4{B1CKfV1erU0R$<&wb~X1>75>CZl+9m(zo#xo!y4iYpOyZTO!2 zH|~IdOr*q_2F{q74Vb8PtvHgS*4h1ds!TlE=DQ@f%ptMXb9R5m2zIuxBB#u<)IVR3 zxOAp&2)o>EcivL&H~jrO^1?ii8n%%`o-h3cFu|K<13lL9-{cItH8V${-ZD#RYo9BP zySrX3iW3RLVtg|$^I(tF^v6-xS~o1BwEySfKQ{6p-DIXq*A%)eV=em!%YvHq|05|F-H9&K^A} z+M;Lk8*HfJp3N;w{y~A=@;R8;ooHt==Cl!_N8xUnX?~(VUA;U1_@CfoB}9WN+!VEPxW8CUa0CK`E!MW zO)Y9t=&Q#7S7M}Pd~{S`8v2#_n&nw+A23(kdN}TOYuNDE?!LNasV|w6-3+F;d3X1_5d~aS3dkLO5kD)r?%Ny9s-!i zZfE~)qe?n!#vrD{&wi%Eex^|H+{m3Ko{=&aFwNiLPU`Z%!`;QJMQ|8ZH)ZW(+!W3XQn{qA za$Rmt+_F8n?}SYhutAD4aEEgIEsv@Hj#yOWC`{>+IlRaPY&NGK8ylr30U*#a(OLf~ zalhThz?enepsc1cBmWlfs|7ba6d);cy03B}4nKc29feroASG*xNk9N%+D=>Ao#te6 zbbf@r6{3bYBoU<(Y2mg>T3TK-*bq~7nLOKj@dL%Xf;e}MH%ooK3T&aoj{s*?L1-cD z#tTRLDRL?Upo3C?W*~^tKdT6z0+t#9OF;mos+RKzhQNde^5YVkzi&+E^v7J{2Z@T` zs=iJSlay@c|7WIJ$d@-LqyG4?dAV_x?&bSJgrTGLPJeI(R0yyW`ac3er&#s>1Q?eD zQ)zg!Ez_11Q@>fU9M-qFzNadd&r!FlLp$#6%a#!NDge0l9XYL}-)`w^TUbdCZmBzJX?3azi`Z@#OeGz|S0 z7DE>mH$W_zaT-Wq&O72?L1CTVg9grLS|apg{0x7I7@uFxKD6N_PDwpa)P#~L5cUJW zdXVECA^4wuz%>T>V-L4+ni#d$ii@j5D6!esI~Mn;yOxq|uPeMqRN6kE)S*f9l1=I3 zsWtOlP3ZuHku0>jpadB@51@DsJxeO^Qxz=~oMuZ1OUx*kmcV!L9{wwxVD6V^L6u5> zgYwtMPaU29+Y+HffgKCSYk)~a%5m(qEl%bbDB;uC(>D=~;e}#3V0cKYP(Sk-Te17@ z&II$>IN{uI=JILXIJqTr)7Hd-O5y*90Csj(O|;W9qgbLNIkn^NZab6W89(L(n5=Zt z`DIOpS5KJj@{2wyFpM876MR18>JpeaxhayAA@-#op|v3_rueaCvlqtY#?{C+vnyW+ zN&v-0=l?i4>9#1rY0u;*hgZ1rzM3gY6G`IRl&R)@8nYHt9&M>X0*jyB zGKTMOmmeC1*OeS*w)P@=#(C%3ReeU1gYQyXtp(OIk82OKDP+}8V4lwlaUgFxf;mCOmxQi6fNX9J&tr^^ zYxIE!A+#rgxaoeJkXF6yv-2`DA=b+<0uBN+3I1WMle-cxCDQw{Io@%eKdS& zf9R4s)AxXMK|4!+BezK6{Ex(P(%$C%Uu_|;W_hv=%ZUG)IcX}ss@ieCsd+1*362<^t&}|iU z{ZADoV#UI7fg!mOUy82U9?|amm!V;NR9Z>~KhW^E+98Q9=PfO-(-IwFr=G)uWvEhs;U%_?J1v4Szf6Y7gjB-WNg)q~Cxl3KW!t!Kx zdb9IKno*MOgAM(41OpDx7P_#20^w|+6SZFQ zmGhSTu7={VS=3SjSm$IS(IP`L&_X}3-clCAuRy+52aqS`rl((6@{gclySKdTNs~(< zt=odByiN+Fe(H^>P+3$4JU2;yml9#9;{p*z35?$?atmevhDW_yzk;3^*HX8jKz+U+ z|4eOi$yk|h?o=4USe0oq6_-&j=>KFwWh2T{D1 z&Am4iK(5xBtH5UxD!J-Eee`x~koeeeel_pkr6F_b944QOJ{#tLBwrHF!j)HY11%*j zSKTmPAvdZ^1Sca4yA%)Qpzf6^=Evp7Ebc>^?*G5*LtdN3-n&`KaryZ7OcLHyd?2Qgvo4WJnqBlHsO-sAcc?Q(&x0_322ii4yFI3+uVjjee)y zlowHq)Di9Vwpbd@^VaoV>0(1TZYOi^y%S6T%=DCmE$iZ!?>43E`xP+r8P5X8Z+p3# zXS!A{UwnlI_nR&Td<3x~3IIBP>r7SNk=C@+<5V5ZSO~E?Ey8gM>=J$O`S;k-47XRN z_p(@0DJPzh8n@*)?9|x6U(b*{8E8%O+_$=HO}jnS*R9rAI?VHSvz` z5{o9@TSn+9)^fj^a4h@aD^zMNjBr%KvszMNqd=X|T_AmnN}E4jgj%C3W#*lHR|@2v zPS-4u@4Y{sW5Py1v-hTSl(cO-Zt~%ps24xF|AdsM z6jqoo_Ux}4h|Vn)+EsNFkhw@xMf^A6M04wB3l8%xF|9aL9$ADc0NzquL? zXj|HBWaQ84euzjFyceDo)j{SW4@xPsF-tzDQy^zG^3L z_gSwN+rTniZFgaLj4sM&V|G7P>v`0dVl9fm0p3prZc+Z0&65q^$Zm$LKZ!285~B%h za9>(rsP3N*-d8@JLm6&rn%#F1MZl~_5f;Kv8PEd1zyW5F7OdmKBrE4hA zobkK3Ez@2cVI4l(t_>|r7^Jz=|IO!}Q{Rq@o$`2Y>6d?$>Qr_cRCe>9Eg&y6gx5Q$(ndx0w3b)XjfJ>Rwe`HrgTb9wTq@~cub9VN5b2F+ON5B<~ajfHp+<6*N z0~9uDTd^Yvbl>0a5qDQ;5{DN_G-aw=gUROwKv-olj;On6LH?~+j;d+D7=tSCw?fLt zn%~w|-`&l_TFdr5W$Wd4#qS{>WbYtgoyC4zf{~u*GtSLiEA>O%QWs5j5b%`=u+5(8 zSIY)&*}`KJ>0jFzBLhnb6(xS(oP5~7XSGt&4sLI-X!KS#iiB5Jl-TIhd*Vv^$HgC0 z<9-0)^3+C{D5!*G!wylpaOlItL0}_joXBO|A6SZ*h(_i?U*c9RkO@wBRSXz+1l3Q5 z>nGIlyn+8#T784j-t0z)X+b2f$Efj(8~qn-_LJVdi7_VBal0+B)f@{_^ZoYBzcIg% ztZ}PNj;4J~ANEavZ}M}BQo(bx0x#<@-4|w&5aT23$YrEr8g-bub-dX*l4pDX?C=hw zcW%MfWmi6CHGZ#FlcB_0cW*r?xzz3XAHiPUPn!}0w;Iwk_R6}sS23DDrxrC1oZ_xs zr^)wu);=v3ptv>#XC3ss-R1>bF(7*XbCs@}E(&>t1J2HV_f;u(_-&e9==vwkZlP>5 zl~!yZqplJ=v5jZ^rJPsSO#^urE4ocC6Y+Z^>mH?Z=rN^{0c|FB-t6!Hb?4X_e${m} zazqA5Hl?t7b11(`Jg3rQen$i?D(&uXmgd*_TvFi$U?7A>vQiOvxS^E~ETwrVrR9}u z>;g$ZI)F3LfYt9Jh}`Ad$DrE6k`1c1C#|VfWcakO%jP|vz*KX}!kmFPZsH;S*BkVXO%V@~wIP#`Ps;5uGULU#ph@as@i2~S(zh0tFMk-YgNHIZHv<9yeCLaf8aJ!xdnV!Bv!j~ zp)umrL`)_e3RY&42E=aD9V(3hAcI+f#SK)Q%?4 z@wx$z?v0|xQ&y_*a!ZdqYyH3^Qaxzba7wPKHL<;3-G1%EgY~pYMs7OC;p$_9#dzP5Oy7qjZS7E@&0}9A z@ps(z+inH<-)`l1_FMVYn@>OBs9fB$Yi4&CrtQDkdLivocO!b}jqMMB8QsZYq-_-S zdA;wl6-q+-V0{7nqz25oM~Fzj7S((eaa<{}@%YuIV>HaJQrrRlz~<{AHFsV_FR+8G zG3;EG43?_PiqLz>kiQqYT=qr4LMRe>xcz)Xyw*=^UMn36hT3%|fVr~@oqq_8=1wQl zWPtmZ((0m=BhptV#q1*4!gr3JHw@HV_59Qb!fH^76Mawz0(|bue3BRzx%VXx${f}r z$6iG?k7UWzIcXDE|9I}F*d;PBl2qR4+3x&Wpmi>vHal<6kB3J2;=8^otdX9+JG2q zzqY;&$tZec2Ah78;<=f|1podc$+u{FDXbCLjhis!DtWwmHSI~>kD~9DS7U_Y!s@?7 zG~qarFQ++$I6?gfo#uKH)ivGg0Fm7=_e0_%vCmJv9)nQ33l(8LL&+SU`2t0UQ}RwX z97W!6B&Edb?3EsFzGW=&mz?I(P9+%(fluZl$li{Y-Uv@aDq3VwHmOCDOm(F*K6A6Q zIUd?q%uxcZ#qaBCufD|AnPa(Xi4&CCiI%bfSCza+cv|9mv^7+`H`EKq8j!q8pL<&L z>`NyPX(rw|>(qL4LC7vbLzhoE~-`j?DdIgUKM$XSn^mw)=u!D^oB z-&lUq@_&)h-y9+c9@uy3uFHPp8eClQ+qb@Z&lx47F7;MyP=L?i&yQq#s~nz7kSR=C zzT{!Td7U`Qa}`y*LE8jfIMEMB0sjriszH%b-6mw^ph(@mfUBzAz?@UPcwr8}(ck8l zCAS5%$S5-JphPf6e1Ay<#rK3bSRV^S=zmkrIo3U`7B4(X&6WiJLF>{n0N~GHR2&|W zz5LGV@q$*9^TlT^#_cDWM1I z?K(cYV*RTZgp-QCS>WwkHdeKv&Gp+wzNQNNT))t5X#}CSP==f&a zCE~s)em%25y-qQb#mn|0_ zN8RLkAI7OiUiq*Q#|~Exs+*KfRnwNs3ZuGdqpp#m&yjws9f`h8e;pJpLI=SMz|xci z6#T~Wt;T9r9zDjgpz3oWuV>Z(RT#5k1@rt2G9T9Oj+rJtdy;%4%**pheD*iuOaeC- zl@$>diEPhNHt?>(9COf;oRt`riWE&MmTR14FtjYVwGoy7v7O#3i_`22GKyl-3qZG~ zAOWJ&xFvqlQ#=)3^NV@j9YK^8t8uu$aU^K*#iAzpXrJ;Vx(+1 z3HDvu)D85@JG4(}Rn12exyf=dW}8YPEPZRw|H)-Nc>kNrME>Tos*7cebnL{Y03tjM zv@Zcf@kEH2>38wM1a{D^r$+1@Z=cQzHJhTVumSHwD-tqIdXcL!I`^3!Oyve*RN3g4 zNXJfARVL`m@LY_0QOHZ~Ko&|jDYNd#UXQSv=WF>R=t2>iL=rY8*dzQ_#Pzuf`+uT= zobT^wATsBj??6UySj9Mc@bcv1V+dvJfi64Bt!iaKK4h5_0nk7Y1tmqfIp-M;)U`B~JSqNtV zA9l^B-8;cZbt>k!NQ>!<$RO*X5lx_JIaQDZ*6y}VqnM5ZPoML+gIOr73fy7U2Hf|@ zkIwRT&7w_+D&(BujG#Em)vqIds~h_4MfZW9X?N<4NQTed1bx$t@2hoyO7R`2IjZG3 zcUP@7L#F=><)X2Zw6V(a``EwLGI(YrBss6PBaRB!-kNIt?{w}%CQBhNXOm#6$QbDJ< zA5D!lw1G?7b?&P=z*5_rD~D2BNv{mQ4^543=OejQjWrbaX_*~DMBJXdyKRryk!Ab3 z&H|X;Bu`(AfR;zeS1g%s%P_0J@2g$jBqtA(_C&rj-D&aQx2Ij5`jJyN>vmOyEuvML z^gXjfi+3`GZ_;6(bo+%*SZ~&gu)iEvOP+e{iPScFt}yiIF%+!o@7t`8mf0awl53tLBK<%4CkE+9b!2zI`a z0}PteGzOT#k?|dQzRcTNKv5kqmmhRntIf?d3=8N-2`c&faxl6g_cH*TU3;A*wuTA1WT6Or;7Nx&YiABFM`eEOy~ zGOmVm=5%CxvxYZ1sx z^f3>|GNQ0T&~l6TqEG`%^yy>@=ggcDbKxJiQDpcsQp+&I=GNu1tt=jo%0hlidty1V z5yEiW_?+t{uNNuPUL^@c{3s27-y08QIWd7J64hdm>G3Gp`D5QdQxB!3eCqR(#koK} zxAUDU5niZ?v;n2MiQ^&>QYGp-l*T6N%lm4&u4CxX^M<#k^Q*@kHWHtUx53XF@U@r5 zOFmaUT2!M+SM$(fDO=*(G51TCG<*KIoAVJoX+r=RP>c*v8<1$jhl~Xa*DkvE`Wa9C z;{v|wIz9PISNI0$K-3A9*@FMZUe2QF`2RBvy-po%LjE>GM1 zJjID=IXa7*p*hn$+&U+2DRy(a*|A0BimhbhQ(UqKE23y?ktf;hf-HB?Q%&zs+(B>5 zfAeAd>celpdINuA%PO6=h37GBQes!U3{G8I<`fkjqE-Lk@9=IE_SN(EN zbIO{m!f;IT-1XMDdD*;3{_J8ll|gs#zcN%<(pJDX`F}W~O71WeRc^=q zM@kg(*7ef2{R_$({OW5fy1KDJ%gm3N*AqftisgJ~b0wyd>v-r6g=^jKG7!rChi~LC z!z+vu5K}d9HB)t#8vRU@#kXN11tRw}VUe)93T!wx&}T6l;>LZ_+$9~-YQGIQroY!c zT43Gr>7HkxQTwOBhJFSAG5n%Yy4&o-)@Vx;GK2QNewI$AfBY^2t}C3EOe?w&NzzgN4HNi21jY?K&%^bVQxL-2-*^;(Y9 z71BYR_@Gfu1NY}Ve51$dc8N;7-)g7zhY_cgyLq_nLrF#=vnVFm~?Z5OEH+p z^@YO&TjklY)+L5<###&+vW^Tx6+%c(+tgZt@!@PdGKL$f1#1u;eK*J!?$I-{WzYn0%3ROrK~5mBoenNx1t3 zQCmOXNPEZuk{fK8`*p7RS_zwoeQ#zgXolEyvpazFV5J|pj;d-1d}q7bU#5C<`A&-A zMzc1+{~(+w@B5nA!w};7hvc?2;jDBoLdXu#j6!?~PSA`zn$PKaG8ud4ErXyUXOUCE z_!6|)vg58&)Y-u#LR4^9p6rlaFW8ouR3!E-L5K|?LY?Tq<4_uh=|KnfmUJ@S9j+(M z0VJbOu-RWfuwEWp34SCRg7yOYrb3qW*N2e@)^|CA>d|TfNN6}DgbzQyZpU7hG*ZX$ z$T>#SllnwgCdHBcLE#g=s_PC^8s{ZpW31mh`4co-xuUy#CNBs~vdOu-%zFJmGq74k zXI&2fsNS*2IUh~gI`zIanlg6sfy6sd;k+m9*u3Y`&#q7MMrHTGS*??uGI2>usqdq_ z_m5hNcfP}d-aMJEQyaQx2G!gn>T=%o`Nq*JK`SbG*FQC^ctd)pXzqF03~d<64pWFV zUC2Smk#KV+Pl$CKirlo3$i_dAK3WdOEs64y{krvr`=5l6-Wy2p)gfs)ECI_D8=LT7 z%&kxCJ4t$%nDzbkqfDzAH80)(C`x|4w$3TcIVjvVoG5E%ftK*ltV94R| z#koGvM-RSTj94#(%@u}~Lk?|x%eWwiNymq9*g2y80@aPy9p4rn(Dr@5z38^g7=Krg zF9{phx=7)jSUE=xl~f2fr)!n0KTw1yePDf`K@XG5hP7sq!UHPu@=xkzb1$sW2- zMkM`U_J_MAg@Pv#O@F{#OWs1R_f=^f%9x1ODr0y+`>|w&q&__+r)^Ke#5^N!x$Rw4 zHiL7L$(mW=aEuY|(aaV~035nfyza9%7vryL+pY=U7x!#CoG6BlcL_lkl3)u-zZPO( z3o+zbh^Y(&NxJ6T#p5x@9yyt~(|s$|1s{R?W5>y`Gqwxqg@JCv4|Q@s8yIY+YMW5d z@w0!lT&hHV?Zs2TZ+_VTItr>cm43ql;dZPP>4W-TI~K-F`g>lYusoZ58=J3SYNe!o z*O^R>Vn=Gm>1zv}Rj)N1 zV}mmkoU57~wWn_z_M7uA@M5E`{!RV(9#@N_T3hGv)g`&{E$UvTusK!u#7FPOkE9#v zy>fk6@2|Gt6mT0C>m`8;U?rKzBwUbITcsd&bNJ!yjAUMF$t4->%ANao!vxpO-lHgCWXKR@@HINdtc#h4 z%bzrsp-%)*P~3Viup484+oeL@DT;VF>jFM}`D!BDcdu`hpZxW`zU=sAUlXI~GB|6u3`69k;@PXN8+gD7R4u7`8}37`TAi6-Kd)&oX! z<0`~_T{9P2lg{vsYFE>31pj}DqWMXUX1VXv;JOTBi1_Iw=XdJs{{U%l_7L>%=Fmw03sF5+r|#v zHwGC(EZN(Jz8c19D!E0DMqICk(;iSj7I3fq4l@&bgC4s*ci+7+C-$aH=JXkC=4`p~ z1S!VsZYin`G2@pxjSn|=rK5yzFHCF)Cd!i{W_eOQGlpf8hMR*vJBAfV6!dqRKB18v z(sd=$SfFQ>0r5CJmM$8*_xretzsH#v@}3i15@^#0J?7Dt`dFYCs3G++miXo}>*h4; z1}S-c3d-`oK7=AbJ2%(+H-P8QsaxS7T7R&U!Q#%MSR2C64}nB2d)a*vG%w^~{2rNk z{fTqQ75Qx**katei#&7KuPgTkwv{6`*TXWr+mO}3m=T9iAjP6Re9<3?@V`RbT+-fb z=et>}WX|_(fa5qGbP|qMfb)&oP7qVq$mL4(A6SQNj2#|J`RG`AdZAC!amIvOBs^+N z+`>k!z-=|-Le^=eS^-QU(6*F2MUKU2W@x0c-GM?br6Nid5nE16fx;O(qC_^CyR7fU zra$+za-9Ns!xU%=SdBP#Gbb%ylxZkn&v9Tqo?_fI2pe^N{Uy2|y7ROB`f$QK(if%3 zkVIz-oQ|!t|0s_}UX+mcid%6!H}}cQJbcRl*1L>J1Rw5ImOim@R*@~xyzKgV(lzyp zkcEn5gR<7>TR?R*)>Z7BOTtQESZZK?`y>3vviH7~J~87~8LxVnvTPFmR66+$`EjU< z#eEFk*Q|;$Ch-Ld3i7cBUVQBd0W0vYqf)hRp5m3+^tmdv8N1cL64v%ad2vEp(pwLg zuQFgRcZ+1|r>Jf!seUx(h%=$k&Nf8HavebXu?Pw=P?!;0&94Rn+q{eShs|Jq& z!8~n=7|uii{*rfJ1ws=_UOcjYge~3h#`R$@-qyT2Vg2a+zJ9dBYH9YqtW>}7+iP~K zVxeMFEaYkP;W`##I(#F8VY3rYGE!i@D;m>Gq<dt@eAA=r1Sx;VW`(Si@qyAG0qT0uH`qk-;Ac| zuISa@11!5lO0rHzQx7hC+bkH~EIxH`3jW(j}el3C4Xt@B8g%AAA4Ue>h~h)|`uLUe}0ooaY#}1Io$O zFC~kdb-xRPqDPG?epNeqP&qxoW)10nUw zL@>T!Q&x1Mj>n+MA-p$T+qOvmXB`A;R4b(Z0DT_HK}3102+k(@HzpSGJizYCo@>v7 zW2RCK&BG3$0q;H%PxrH;lfl!$=u0**toYQHc|FGk@opO2kM!03F_qO?&f^B}R{Zrg z+^4tUCZAzlcxmdWwkxmp?`9YS+W;#Fsizxk_l?hZS2^iS*Ld0hRTN?FNMrsG;5j~` z3ePuW1y%0g6)K>AI5|H~keO+?;gajWiR%xR-I}LQG^p?4m*-bId+~CCavJh8?>vYx zsYvVvkAuvWZJDq-BN}4_FYTjbomOGN%DJ)3JlI=E;KvpRpRU#voEP5re~LOp)vQ>5#g?_ zJIV7ci`n0ZhWElzg%Bz8xi5Oktqz=pV8#%s6BCwvU17b66`2jm#l*n6*p{N79BSZ5B|jCt!wKy{#Ew=x`qL&K)M* zOVyH?4MlrsW8V*@lkUxm2X3$nA;D1T4;+Yb9-?DWi{4k^l6=N!vekjDEbOmYT}J9v z#OVxZj^F6^;Jj3_#=;FS|D5tgh`U0!k6I0a>Ec-!DdflZXK<9}?oO&u@THuPa`4pN zObAGCw8h6)KL^X@p6%2AP=}K|y$(c;oj&m;R_2XX<~vqmEyHwOPdDlls($?jF~{6} zT09g=)CZpL^QFtLy&UdMfCb(zI|QZz5uO?@0y(Gl?qyvL=>*N)aWv>sFC5GuruD;r zHPnnEZ#-tZH4ymbh+Pm#scXYa+UrQYcxfS?hqu)1>kYD&*Y8yjh7ksoHCl?1#(WkN znMVNjJPn=)NI+$sWX$tZS9^vtwLwtedb68apdH&t)UQ7Q?SQN01EOwaG2u#oaL+qG zi@kmvIgB>XG?8AKz)Uy&=TD1CobW?7df)Cg{M{=kvXTDWQ zG2Up86uEiVWbaB?Maq!LNHmgjnrFr;=jR`4JiY>A1VT|jjF9c>IsR55e<+cb0LjlU z&p8Z1QL@Tu#*>pWF!S154o+&%wJj#prD=VczT2?$s+LYt)PTf7H=|<$jp2ZE!+f!l zI+X3m8cR+q1nLtgw&_-s2UKMjullfel*+&S%>dH!4MH0DEocRzx%0xgn5=|7=uGBsSVElmEbji(;^0B^kjoUBT9gYH0|Oi;qc}bNSZ<!5-+_t%oDOGs^VhZQ={jg6gB$$mQ&zAJ6l-L0Ok{fqB{i3o3we_ zmoO7-{JefY5PGLAs-APLX+YtG)`Tatvx*NybFz@58PfP%$WV&BR3m}1-kZRlrrh3# zC%|4t%1mM<8#0r|{Jjm%Xp{JgX!wh4%CysjWmXKp2;geNv)VZclRiuzh0H7x(iu-! zbgcOR9kh}*83iw^J&r8xlEDj5ODMeUz1ns^(F)}pvq({2v6aY6(kQSrANJCx4)?=< zI^&bF1&#x&penDDWk_Zrl$lI|k%f7h8ekQlFKDrIVzBZT1oJ(p@fIW37Q zHhO|X*&v+ZYqit>KitvJ`N{@(h;;ojjlmrJ;cDEbU@j#&VL?Kk&ycr4+v|Z z2RDtULx7S`C`m(9F5te10T{2T50OibHi|V6z|y7YbjSKx6!ziBO`H`)V1@*czQ>0L z>_WdyBycmeF?JlzEL%zORVjJZk=&^3HA+VebTTRJc)**B8!K)j9uab=1&Z>tj(n9Spv1!__>CGcFWi!(B*h!xf@Jgd1ehoUYLAOq0rwa^oNprbh=bn4LOW_aBuw^0oa(b1YX|8`N)OuM8r+GyW)LE`o*U=CtuS`_-60&nOQ4r=C&7-arSusYBb{ za?B*fo8?#O*0PRn1XstW#=d5&?r<*xYo%SUS}JOe=(noAs<>Ly%*}nZxAspW^+jdV zN5}Ra?mmKSn(=_c2yXEyZqc3Nx|%Z8QEF86^KavTL-e7tux$ljbx)yt8|*b$8Rb@S z^3-gP<1iHwVO-mA2o8dGuolvk+7?DD0E@Lr(ZlNMxC3fIC+68ou7JMgSMa@TFxZS~ z3R=FX)3e~A)y@9V_@&`qPpu+BY@kKcp`}HuEigv=z5@z)jw%@e_F}cVyTB5f#0A** z-*E7OV@T>S8aW~Q3lgbHaSRmwvW9X$FkRUMBNR!-c}SRF6c9g%DK6^X;~e<5V*D#Q zYXo)op0H@|MRkTUkfeItN#=VI*j#A*z_ec^)`{<6cJ+=N_^>y>=FbLq z(qR`lpt8UFJGwI>>;&bfz6V+}-A(^(&D3J~Piv-_9Fup6fn|^`1jZA7q>`DNLfj<1 zaNG)mv&Hqt&pcbb(~?;7N60PKxYZjkaP?2r89Cc_dKhxnN#V0H#fiWsr((q zz-KQEDPco=%;5G9r@d?bkae39x)l=7jMzid(INHPo&mU|nCr>I$vnzH*8!hwNZ@D* z`g%}KU%4%DPl7q3)vFQgs%I)Su7bAtUt9} zihhcM=ItL_E@_XjWcH(qC8A{p1yZCzMF=FDuk;-H0oqzK*>%S? z_ES1^=2n9n7140y%bj!2hkyoGKgw=zHB5H5?GpmALZ%1l;=uD~q)18%q?dssbgshR zctC^=jni*Vj;N93T6Q8Qq&MM$kkkf8Jw_5$IHYu!wRe?`p?74*<7rt&BYdA9>_9uP zIQT?;1#~0Qd(i?;M|{aEr*o*3n2f2XrSHP9IjIO_6+kOkKckqJ&px1+d!9`O_QwGo zSoXtQ*XO;;uXu@`mwwPLe~*E}5-?n|jhIALd5ti)`jBd$r}HeP{bNT;{^&P@U3W73 zAeZ3}ZCr3~`#Mp7$IWu``<&uE-S`eC9RjX5+z1}aJh&G4861Op1v6G<1RY~{hxLD~ z#F%YKq$t}aYLM4)sH5sp6Ey3uFj}>g>Hvf1LW5;0myn)ZHF9h$1=a;DK;wvPo&}1fVe27hVW7jbxqQ=ZqRZl=rSX zVyZ0l3wrbp_$O>-ZBz)$%|B)%8H4vcbY|VS?jd85La3h?GP&vXWqWbKI3gCZmFXjs zq_>>l2)b&-tz4Ux3g0Tt<7A7Tw(W3hHH#J&qv7i@P3~qPy-IgtC{|c}jjlk~CTykM z6+H8-`liBd7stXF_eEkkagrO?U6*g-yYtJhcbofRaDuCnk;J2r?tKieU!iQLk8ODM zS~XO8B#eu?t+0HsK~Ph&<45Rd+fiy()SO`=B#VcaHIy;be#|9uin`*F7n|_ex{Fb% z;W)D8J4)Xi@KkU~uJgZGqb=)>P!LDtDUp<%<8+kLylv(ACWnYE_8mmh`6QXXFyd>(cAJ+HQ0^P0T@ zogFI_s(*>B(pCL?7oz73GH5(qacSG6vX;tBeJOzBt!yRd@zcq z#x!OAom6qtss9?C_q(OS>c5r~w<*CDW#XIviSYz@K;#}UV{dp;?E9@khQ-d+N4Ix7 z$;f^Ivo)berOz$SO+!-51t5c zH>F~bZbq}^c(>N~^_KU<F~Sx)yUmSvcijf!p~fs!DPPum)(f)W8eGsbOBLr&Zn=-}10CWY_+jT3 zabv%t7liTFp!xCh z(a7Yw+wEmEFCg{a;tToG!U9SJGipYXTQa67NUBdVw|2oYEEPgPSV&_=Oets`eEX$) zO?e0QJ9LgC4-~S|0vSh>Uf$Gxqh-{1y4&g*L9ywIuH)0T`|Njv4I=m)XhtT=GZ^cI z0hsJCyaDg}bJMEC#W5vASYEx37*cN`lx@<>0dfAc5Q&(#pZ3ej#kzR+&~R9xKjoRh z&j*UjzFARoJ&cAI)!apu{&~6S5x+zu5*VMclU_iQt|4a6fT}B1gWc&rlJQYV`A= zgb@T<#C*#EqjxwrM8VTQtB~iI3V8f{8+XgHoPl*6V|<(|~v zZm#uw6AgqRg6Ow8yXUg4wg)SUK<@kb{cYprONhsO`s-6ZeO#3Dluth}K4p<1lhNes zq+T5Rqp0SDs5lwhlF#3z6F(->W+6gZ&O!#E8N`y}Lfd2`z{O;Uxt}ug-&g9Svsv<> zf$-&jQ23Mn+w1VY??c~BUU8{!J*>J0fA4vea1$&te?rSi%giPZpO{@6?b+e?&L zDQLu>Hc6#tS-vbImO&0%ZT$-0lxccTSH{#lq0iVgI~GLi!VTBhV6;D8At%rJiUfvm zCX?JMxj14stAx}{uovySOJ2Q)UXbxjUt}WAhois9*9T{gciG@? zV~0}n+$AM1(rQR8I`^U7y&$5#%{*q2%kd%qq}=aHDoZ{bx3=ztghObj(EfG9qR$l# zn%7^7a(%u`{1x+Lxe(Z{w+lhaa#zlTB?fsgIR~a$d(C&uLw(`*>lCRqRCSQZa#Jia z80UFWCKiyTt{IFrMO2fK2&4f$i2nQ*F_oEKI2FD9@kGHhs4bT-5o>t3KF84gH7#UB zWW&CMv`+{U=KWR3qGfiq^3^=~-}B!43N7|ZG-wiy)-uMf|DMeZnwcW4=nMW+c>@4q zfbxdx1;rH|a7uiB0aF0VhjtPxfbRnOZG$pJq3*8$tMmt{!o24qBheZM^UjN{iiRT? zW7|B#TV~x}mR+;Ev=jYfDu8RWVE?yk&_bXKj83aLgz>wW@wS?HDDl7;3bux35VA`L zRAEUyGgD!^7;V~fjs-36@%%pdO`Id)002^t_6I`ieJkN!IyW7C6nPd+4mmabfhB(WLIro78Lt4=nd|eG#2V)gw6eUFt zIUko?XjcWhCuet$%DOc$B)-W5%5ITZ_T(z-=%Z2+>uWAN2*_7^=vXPypq-Ly8#&-s z_X&R@FW2s7&G1gW6I=D@;5MPj2C<-Aa;9{SE%O83$zJU$nf-IB;3rKYfR6> zzjLqokMRH=H_3IhzGSu@`y%aaako(EreA>yRu1y^&Q7<=0`m)%#$ypT?W3<8V`9X8upZZ#~tUt0UJi2dsEhKs)nNTk&pT#Q7i#3_%>Hy#EeP8~{k zy?(6SXNXPqY%c%GyT!(0GRa8jOI2*;se4I^N-S*THmhx+GhYvzOjxL z9R=4b_D^pN-@Yng;#^zLI`7Bc7|dUP_r}2Wh%9%k7q=?2L-T+(QmSJNGCW4SKOocg zuWfzYO=eHK3HUnE;l8m2c`5qOuBA&vg8ukm4Hr2;Fa6)n;AMK~m5VjK5u%T=MHe?v z6d+&50`Ple@v7=#{Q@Aq`HO%%fR?8K+k3S4$3bp{y8dg+$_Yx%2mc3|J}g4G^IiI=x){J{^!h^ zx2`E{q=*Y=x!D%}HoTi{#v!}hIy0D?w$2p1$7SgPuhz_yb2+VGs5Z*Nlpmd>%PTy< zNit*-M9NOruEC3PtvjG)8l&Ewq={5$s(Oug%sEAw5cvb1*DC5C&ns8gc*8Oe?n8A& zOX^?c{B#0c>?)o|{QRWddSi;B_VY_t9eumrm;VOBe8&F;!d#v|Iyj)r_0&q@wA+nh zQD5Vq-dYArf^=Sg)mm%}5rdKbgk>8zNj-4fcoeW-!MP>+?2USCWSkI*593h$F;vK$ zG{zAA1kT`99>)4t@kL|)8c0TY zT>#1KQ3Qsj=hSFlnbH4f3r2i?pSR=f+ArVN*aW&yX#DZ{z62B6y9goop$S+3_>g2( zX@|q?qZ1~M2!3*_p=Ymgw*8slGe^sU+7L8I7vZu%ahTN5S)mu=dhqOkM~z_@eF~?= zZpaWN*jRC1%?6EylJB}WZ6YDyKc-G;tyHnIeN>TZ!$3VF{ZBpP%wm99dmKW>E~^Ry z=pW7&55a`@4cZ+Xpr>)=6?XGCO|Hn-1sN+=lhe^pMT-=QH6v4wRxHi@ zvWf5c;k>3OH*^`b^uyh)+pRSf%mi*rNk@6%B3lLvK-VRbg3Mkq?A3-Mo;UYyRt7|U zrzIlqWtl<0y_-DJ+`DyL894(Tn|_F+qOVR=jVp)vUA=s5Hb?mqKvB*3{=rAkXl_^C zpi?$Lo-QPG4kr0RFa^`ufPtP+aUn0{Phn<*z2!m5r{#V3nu^|2esbEouy=GNFf5TM zX@tluoy+fnIXc422GSq%`PWsxUL)^KeV@Ax{M8BcwlGRqfLEYsX z&*(n@gTkes2t&d@WmPo4H@>E#KkqZ% zN}FvlF5Rbx7DT@S2S9?wc;s_mqTLoJdTzT9W00qPSX^3?kTzYT21z{7@4n+^JekZF z5YjQQ+S3fdDgklaW00#tb+0LqTHvkR4HAe7NXDBkRi0cky5A;!8C)2Q^eMrZkU1fS zD|%-ZY@qc4u&`#K{?dD~ZSUb;m>HV1I3Mg3ewI$?R^o4X^IMbL1ra_$jF2)35{_BN^N1+f;C?gE z@oyo-@*`(Z;myPJq>#+~hjs%`m_z%31wem}4SxdzpnmRD-B}s?#gzw%lv+C;NL_{X z8~dEOxX9<;`)0R&uo}Sm_jNn*XOKyt^-p?f#bRq1&DX5Lds0R_KV)%fcEp0|N*5Gskk}RrpGRJ{+vedHH3& zcUXHbpM_QI)N^|sQ@i-PrRqa7%>>*EuA!GFOEDIejL#x~U}O&Fqu~!k{zJ0!H3KKa zq;mc)p08Y8_A$8>ZVD?`cJ~UGu3A6LZ;ncwQ|HSEFQUXT1{jP2f+A+=Py;%gX%GXp zdOGPF>TmAp2Wu6gh%HX@;q)o~{u#)J-F=x8P?&@-+$`{Vfr?iqEYmL26pZxgoC&-C(tnFx%IduLROlYw|mEM zenbDm$46iH4dD+uxHe=f&HDlOpj2EIzJ%LyVS1{%$iwIwUY3t(9;oN2WHU@sTVE zTAHc2_q`<}Wy_Z;jTT3bWFIcRarX2yE6nxF-j)nBdwE|0?KR&Y^19G>Q`!s8jO#=L zvi|a7K-OP}QAY#;zh;e2)Kc1cNf#QBL^v~SK9qY5DDP=_U&}~bbOj~BgNckf!y^c) zj}J@Z^JybJ*1>j<6q-}>FB7q0sScAC-lQ@@AwVpUFyDR2Yc@_2QWU3p8_a*VG|Jk4 z!-m4{(hR8ULEjz{(@8dX;f+HaT-p%74GCG683o@TGkbDF8{R;vQGU-ErX_%(gLHY3I#fruJNnKKa49V;S z{wa+UJMT>04r?qV&Llj3>tFh(B&%x-OO+JN4RJjPy21r|`0>5!ARAv{yT?gnsQX`4 zFJAMGJ%U=9I%bBRFI<9U9I4^Qe>rWIMLc27h?&{mGJrB(z|ytpPXSDeuf;OzMEhUL z_{Ui5Mc`Acg^c(gu~vTv)A5?Z6$w}Q_rv6}bv+Gm8WLz3a2l9(c;|9I7QI;KffU;4 z!D*t}$S8Wv>HVZXNN}{_UW!iXOq>G^5E+>?%o``$gTM7g?hW4LPk zOLP14S@)&%9bj04H|om4PlY?8j+Nv_Jy+0h$RRTEq=%02^=)CILkVsQp1y2mmq6~% z;YnrxW|9FqEU2Z(dvXwnlO%$gMEoZn|ItOFA;aq*o(5Z(GrFHVxy0aGJ*e4m0~je@ z;Ij56qrUO?)ma^?k2bpV;3O~({JquUEw^5UQwjTJ&vL%u7;6K|gmxI6M=mxz@4&hI z*i45JBWvC1&i>3pT_H3`e_%6_)S-d8b0eRHHDJqOX{5sS+SwGln4>Yg>~CNb88l}g z>G|^q8oM;MQc)W+FUP(w?$;#0X@hRW=F4R6!OKsV6F;nJ>RX9^NW$Kf0j#Lj1S73v z)Ma&)9b*I9+J_CDw;|TZ&BW6lkglJo35V$9Ei7uCig26&XvhuNoV()y*8Zc0+$8?DhWw>A z`}g~J?Jk&S&&$t_brD{6F zf&>aT4aRsd%S1#@mig%Z6NOm`AzNRlE)RXwccX31@^3}Es<#1|IOf=Njd#AXBtWvI z0!X%Cr+x^8xd0C2rTZ7aK|=xZ@_p1N$SQ27x5droKN(s7cZuY@f-0b|gX~TG#iU9r z`2WbHnzHyGOsf5RQj|?Q%i(q2*j6k8=k{ORtPQ?qLsl-_5P2tbAVaQ*82;mlD_W2g zaXQfABX9@Q3+f4RzX?klTwL-Ar7Blk4cBlft@g3psOKQkI7dZ=chFFHPuj*Vb!E! z|IzKudQ;rZRybp!_<#0p!e53V!}1ZYt4^JZm2* zZyZPv^&aw@F9G=`7mG0`1y3-_+pnfxa7OHvesOyEhlU3ptA1LxwI4p9h%OG|IhGH%$l*yhlb`RzD9(=NTomNs|I`^uDm@X5Tum;9D zf_|@&It*{(T2a|E&7?Sui;qp2xIpR~R?dJQ6gW14`|f+C?4NwVz4{AZB+Act-ar+u z@S_M{DEmG1=gZNj7yBL;ogO}sA6d3L)(SVa?$?THSHcqcno=h?1(JcO>?uF%kCr@E z0*s-*q7GAd^9lYhf>6|TkT+u+plfd7=WLyhsTA}oA+{~OoqW_aOL_ykX3wW4U2m7~ zvsTQM%V;!`O%r=uRMA6)P4HEN`&o_0HmahwbB6nOsW(tVptCnDGgkK7!^bf)<~F3b zo&`Mva>0?Pkh$+R=eL^JaL*pzH!A;zCsd4eE|zWqIQV)iS5n@Kld*XyA zqEy3ZVrb>x@{p-d6TTUheYcTtN#&7A`qu)?b+`eSP4Ic4r}P)~P%&Oy<4@}SirO$f z@EI9Rgjnsl;B?50{7=vQE3>zE6TH~q3*O&O+`l0i`7V&ACH0&l!y&iM%p7K7933q~D8>8Z!a0os>)QI-aJLk3A*t-}Gi0 zyhbWEX7r`QFa!zQJp*X#y>WmsS9yUj#XDeHRB1DSr7%4tr7}ookaIE*2EMi;cfi|% zavo~4Wxte7Hk_mz>@KmV*#krOyj+t6HrrYWPl9P`OY~F)2LLouJAaXC0Ul_t@JSmu zcFc~%Y}nSspSX4x5OgJ%Dh=d%%hF(&w9X4FS-kSb2y7UmVVkEdx~Igj`!zk1F$ zi;R*c?7=34l-8aIHWB=e&*{j?r<>&&FtCWiZ2k0XzTD*9>=g9BDN;sA=}gUEF1;oX z8Z>_L-92asYJ1yg5g9zvq#l0Jq(1x)np6`BWOSWQ*EY^mz-Z;7|H!r1HP%!WULCtD za{GgqUp=E+J>2aD!QOpY{aa<6(NJqE;U|)s?ffA%KA#Xt5%(5DIPZP7n&z$+N_^?OjbL za53OaM38!Xuyum4O|FQpCpgC)#Xx@@UErl7;3c~~K|sX&Jf{7gALj9wVc?giK09Ro z*pH%JSp5?M@9s*2?mo#X6~%a!&wE@ABJDz0P@-nA1%4J>i3nnlW1*(>KWt3>ucJN- zW`WTih(H9U2_vUL+O6VI4CA)Qq^_mhAo?R`y+DKOM^Ggr5!a^mlOjPMi|nu*lT1Qk zD%xUoqUUih4O*}~C~uXO#S((EiC8`MIGMd#PGT)5pSd6WlH^qRjFnen@_M_E6_Y~< zco4!qicB1>R@IkTWxhImd{oc8eDtuC6cixc2}&)+TY zq!7XV`OG22<7b-MyC^_t_SA!tz67G1zW8>c&p1Yr>e74gcwazjZ6Ce~F%^micW47% z>c-oKSyVEPQh)l7O{^hb0?4ONM6mz*#J!O(Go&eqDBBDGmj#2L;3I6OG@?<_apP9w z7u<4J1BQ^9eQN;&u-jmdBJ;GdHLtG^>b0i=MYX3b^&#=CO*$AUf?kC|*-T78Q!Kp8 zI2)6q*odwM0dSqY>)!?}1=Fq^=#21I%RqUQ`W5cLHf!a%6wlC&M3(Z~&P)2AiG5ZxBYUpnY`T7C#)9w7>Al0PQgb<`21#zzW zZv-jsW3G?7?nt3?`1F0D-pW95jS|6*f^*qLAZuSMM7tkO^b3l9t zY14+p&?CgT8jNSDGyR(4#wr;Nfo}U_+q0-gDPsfRg%>72m;xemjO!Wr3P#y-MND;0sZ*m zXEDZub@cpO#34T=?mTiImaA^1np^9nbV!NAo!8U!hkLY1Z+>x| z`{LRBanuaGGYHIy58S7atT02E6zfX#An!SIgkB$ zr?yjAbV$7Gyonaxx3egK!}lm;_4qAhm9?kggKgp9R9|y}BY~GLj64Fv%Qyszq@%`i4ai8HW`2szwN@l$I@c<2Z7Vlg- zZmh8{fgPj`s2rvNoO4nm0A4>4K$^4?uUSu$b>J|eYJ?50cv*5iHCrJ|Bh^2BbxBG@ z`NPTs5efiMwUqn5=1atvuCiuj4=8a;k79l(JaF>$NLS*|JKWA65g0_@;?5Ciow~@o zKAaV!m_=M;NB?|ah`=H{TnX?zvb0f{noCL!QY&RM^*G><7B?GETLjnIM$}XSvck5#&Ka@_8h7*){JiU@HR)v6{ z^oO%!qJC%{sr%dMzg51#)--xil2BblF<7T!O1+;Z3GwT|OTJkC^$`Ovc0k37Ij!W6 z7w|X^5pu{E*B|%)XUQqCkQZCprO!jHYhisH(+3}Av zJFT{LE2a*OAtO=g)2GlnydSlPs}&Ar!(qs_ZOZRf-Y(N?rHK2 zsk~_^{AoEKeU>{m@%cEw3bZZSdo+*+OT6a(HKyUc=nLX0le%T~d@?AZ0#I=`iB=A=I-w*)p;Li5 zb#QjDfriC)P7h!ek9(6?Br<3f{GrdV(s zTvT}j#A0UBBQ|u@F)HK=x=f<-?6Yto7=t&<=HgGcadw5TAWKb3eM|NgFA(NUToZ=< zG%eD}I`qXJvJZSOlj2W3VCsSKWsKl3Udz zx0q&_w^+AcpHT>ss#pXHHp*2ldXZbp-w}>{Sr>d8F38cak>9zQ-}%NWus0sLl8MmN zIFqkOV6UfU#U16i_!3OoFVSGfb91YF(ITG=S}CBSmLn51U~GLo-$@LA2#kjhcD$;` z=~>${x(ZH>SYy9*w3nlZT7k;gGio?c7Kigyr5Nl^!`A-BK+25%;%gY3jaD0yw{Gt` zOr?$cYJR}6G*>(mVX{6Cm+_V^?CHT8kjOZ$zSX5Vtq%BZ2`j(fw8z(SdF*wxmgFsd zN4TFZapor5eiJbS)+B!9ZW?l6W-YsiK{tgEx`$J5_u%cJA!tvZ)Ukay?i{NdCt{Ly?6 zQtKm6Z!v|hnkgy+>u7`M>4faE2p3ov>|-zy65J~t6Ve^G8F zZ^Es$v3k`-PcX?mzR@LihsiTQcnpJj)z#fkx`atcq(N2qf3*KR^_MX?F?=qnY!a3nUWzJtiKx7YD|Rdwa8eK*CC$^#Q} ztMtXdbHB}V{{d(MmO6!anhp6)7B(Dc*l?@f0^jL*AoO$I?~usnNa!ac;zr8b7$2A5 z>-_!8)t@yUcbSlTAxg^~8^?6PJ(fHPc3`hA zHzbxtST)0=EaLHmRxxI}xqLv|)%Z74Qd|7Q@gAi+nmaowR=XFG=F4>Kmi**ZP5XJ8 z&?{>W+%;~hZ=ht;bQlL;Yr3TtKM-%RFKdD8{A_c=ktv|<|G%9pT?x~WtrXSNZK+>CGD`Mu&`ZN(ATXT}SDF&hm0j+Aztn%Ya zq_$C#Ure%uG0N1Q_>MOmYKYCC(`=yYKFc09u`id$P1+{Ik0x{~PIVs|ofTVA3lNQs zIdPMmP-i|JsAl^rL!CzkYscEf`^7#_jQ?ZZoMn7meE5X6spL9lYHNdG@}aC6*W|RV zuKmGSX7WOy=T&w%j<5Xa!Z*ZB=w65X8?i=G#qXD5J5kGAPJ-UZc z+%mX^MylzBUqSW8Y!acTS;p==EWt7FCr)eH!Z+ z0`)4-zZTsG^hp>ofsY_~jOcX_ATcqTeP5C+sm=qw4KpeSGd3O(v$wmbJtUrgup{og^vQaWSy z6(R4~hmM*N{l5|+gPlB8x=4?=vjj0?Tt7#AB%AP;?=StN5(0tii?%j{*)xjJyOD0! z8dxUhv+LICk=O*^G>c8;5BMKci(md{*W(6;vCqROmI8OyftfTN92eJAehm@Ho^RNQ z35Q98D^@-Bi4B74dS;Z|^!AxdG7dVtclG`y^h+>u$PD<%bS%ovFL0rE`|w1HqEGB) zsLe%T3hHoA8}F3RJP;~g?5iJQUE;u@iTE0`|K=@#%|q>Buiy>n4A|)@J8+9Yl zse;A)^%-ux{1Dsvd_fS#pdfg+jH%iSYx}KvPCx1eiWm~W%l3RTQi>@4F&&oDM9Q=< z6#Y1o)?CnhhHd{-QQ@~&A7xPy9Nw^Ui9wFcv?&Gy__ny4V=Pz%9d@xOINb}(qoK-m zhCoOm&tJrqs*NiJ1@GeIrU2^vEjZvWf;NA=apvuN;s@!ioqyg5a!sznIdT1a;$suM z_mj4IwBcZVuYR#*K)v=O#xAUiYs-NquEBh1mJ_|9vsaQ15LL0lRfk0*vmT9}%5Out zh3{v91z2Ce^$lywa+Wd(gX#BRF7gMr5#5rA z_l8TYtL2LwhlZBBoAcV?OP`C1rsI#6uQE(UWFq5=9;pJE4`2b$C=hL;AhLdi!$mZr zpBFHZ$xV)LE{5UQNHRmQPv5GUhjI$x2K=Nv273qg)aZbg6 z+I22F-a69gTEBRa1(#v*E7(_`#tDQ03nFIY1yemsOPJgKf|_^Y#d4N;!X|6hC%J(4 za17r7$9&6|XKY0l7ddNdyt7$}^OhhvV%&QFb5#lN^l)_`@Z;R+&}~Mf_QZ9(v%z>v z$7<=szC_(|q_Hp9_`A+tuHJ@w_c1?UC_AkHL&;dKr?y*J`Tt-kXI?VSpE@T7g-z%V zL+s3m-ViOEx?_%@^^Chle;9eSeE57Is z=pNo9qJL;)Il|%<+zk7!!+N${g~Q3gnfJ|%9s=+PqoYoMg&3$gON#1(s#KMvA{?pf zyuAZ&K2_db(NCTsJ`uaEBfq-?&j(%*)B`3M{WYL18=i-VXN$Off`^f(^o{u51p*A1 zYNk9xoarlR@kzEC%vK3j_1orvB{|=JSL#J#Z}Q@hc=l~ zEG7HXQG(-h_fqssmQnTO;cUo@{#yD;6#nrf<5)f(sEzs>^%vGlItz5+*sw4_ zOl<9eI@&*u5#3j@9IZl`M=_VW4ZTOlKxryI7v-(U?(`6BfXE1 zIYFVV7L`%kcZz}Cw@vajbLL(7%qpV;ak$DZ_3py;?6!+_vz_%hg|$Rh&CUB7n>yep z2fniQYnpS%c`GUF^K9mxSUw$;1?zZPWiWPXt9sliBgvg`4U(^uW7OJ7mDQU*lbM$CQ@_KffSw zJ*4Xv&S2p6bYpFBj0=lY2tS1 zyk!5?E@da;A`0W40cw&X%UKqQ`B+AIJnGo;nf%3Wg2aVP;}_!S@4ad-q9iXLfEHn{ zAa>QCKvlr=heA1M<*}DlDr$uI>4Sa9ZamQxFs;`EBI9CmChk~;Ss*pas_LpfJDi|R z{{8HDq$t+->$T4wnqIuC*sM&p5U<9)$REFW;;%1GAxCMuF58f$D&WK>0Ag97B84D* z&1mKr3X{S~+(1>J!%%?uRzpAfd(8kCe%h;Sd#~xLS(s9T7W||iHnuXC+Hmm0qi2>n?y0rWrIk$0vU`^xMafze-`HX~5Pn<43IM27rh?;)BjTB?Wp5muR z$>>4%GQ5Uw`cr8h@#j>CbLkU@^{Y4)$dauade4oUCUZE-)WSNunP#d%As!2J5&cUhl($Fr{ zk}+&r>#K=6`^BN8#i$QPJ@%Zo4xFapxV`s-)}1*g!iR^=iyYbrf|u7Dgj?q!tt={a zYs!NaWbYSl^hVroO*8Ta3W0PYhZ=)M>p+(c31)E-pu7!}_L|sYG zwb(@I%2}!DZmqb^*iVL$lhTdny?3imk)4 zF?u-#hQD&VugTKkv3*sCfOdS2DSr>|xXE zCBeXEbre#uMg|K63s@4#*K1sfz0@k=o^H(_Y>Ux_p1>u>@gsxWUNWL;eFaWgn1)7b zTcgvb^DCSZ6XX7#6_h<-&Rl#Li|M~ODVVP#hWY_c3OUaSu0xeHavY>XWb8&)A_^2-rlIYukSU^k_I447LHHcFZrL=4i9C`DV?6b(I^t}pRRqaBJ>owIl z#!c`Fj}+oROq&d^$r;ZP&_;x19pn*Xs=SZgyBhA(Zb{#-x%pm6DYnH%DBwL{N|NAAQI2c5w?z z4ga{ba>)uI*l@MiD_VD0@3A}t%jbOhsG{z)0q*X+k{AWv2!oU?r}u*r)O(*xq=Yr$;@>JlSG zDG<8?CR_r(a6qqJC`R$OM56f0C%(7C$Kkz5cqvfCZZhvDn8(fmqVX07xSxI|4}xJ{ zALEm(H2yE%z5=SMwhI$3-Q9I*knZjl0TC6XLj^_Y?&i`dNVk9@AxJk!NQZ!QcXu=A zV*m56Su?ZN%v#?PKRox`d*AcEJD&aQXQyZ9$DzF8RdQ}Zg+=H)B5ypulzlJ~ADh%L zUGzy%`)dL6T8YMU`N|Q}G?I)GQ#S`c^Zc?Z%xeImozs4~Ov#aEQ6s`pp?Obln?sZU z88qv2>LG@hN$iZj@R9}b-S-_xoj)S&8mG)RlFYc!3DJ6L97G#Fk;BQ_l4)t*3}v1} zx4_igdHx7XML$?EwTTBrCJ6%v!&mnQ=uyZkRYni&pszT*tftr*oP6uH%*lUYbNU3i zROZ7@{dwoqGdz#R2xN(Lq{GOh!%U!FqUUPZKKzYbLvzNFHcP853d5E7WK_et81z0? zbqcj0v+lj^BgZCkk52#3Rk^Sv9-4PmRZ z)0Tn$WJPZ0Em57f)HlnFrneHn7~KS-lppK;ZAEYMx)awsnM20@YvXEzxd^wz4;vo8YrIeR)?OQC1o`K7hJ)ke10BF(wolC|R&_|+MG`Dr1QrhMvJR|+ z_FC3D+t$W&7ssd_^dl(d8^}V)j8_7Uy`U&WeD%uFu>P02cvybPtQY(6BmIS4cUylYQ&SVX>^8x`#NR z^vczqaX9G3;Vh*)rD>H;o9Mfh^UDPuGz+(5*--AhNcyDOVC?UnYEZg!Pz$_2dhMWG z^{{x4Vq>U#g2Bpm*QV>hUV>jekxGIbu?SVE>ZYT~NKi_IiP%-}sR$mt%du+Z=Qrto zgMbOVLu~=fhR}Aef9&}g>mXnYE6xKAqpjA9B)F$`?&;+69!5}}c-s7%t5^ZUf{K2_ z)j@PIQ;DS?|H7HRa!6a;_j*XjcBLgr%GEd=$E*LcXHRdSq^?_SwPmZwBQyegM8#qvUBH_{tuL1rW$KMezgWY zpP#I9eT1j^EZEl6qC8w|zqM-PGZtN;Te6Nr&FR_kr?I$^vTv2!Z>CSk>O#h0c>rDf zV{N#vOG)eGl(A1D^6sT$&&ax7Jin(8UU)u|{9zv)!sDutpsC!npS@y10F1y&LI*~cSor1Qtu-@hF`GlB@c8ndmv0S3a5z?X*JBvwK& zo-@z4FBhcv5^8^w9{tqqIRhbCi0%|U^_SO~3E`ruFPF0^$MGu+?WfSDTD=+Zg+XT| z)>eRJ*S#;8f8K!#f1)oe)sFGY*aKa5Z^4vC@WeM3j)B!qc*2D00apU_HJeA2Y zYpkARzFk6&AAB-wxu50S1l062_6s?hd*`PO^@c5e(^DLhtlN1Ii1_qrKaW2TZ)+2m zV9M9h^DrWK^4-6X9~`V1KuiVW79R-quqz=ypECs;{%*w!PxR_1AQz60i@`xR7dij~ z=oCF8k2i3?z2xqW^`}7hxl|)%8so3r>5J1+4#rgpY(&bq_*Vlbg-w(B!7bI}M$uc4faV-hzyBBJ6m&3npYF z!;1hHwe=r_iq=}gCRH}IH;lv6PAYa~8s{mDJnA4k6x$n7x@wH^fAViFAp|Evz#9ny z|BH3GyW9*&@3nE4o37Qxlm6`S;j&)PN^K@^>fY80FztY==64T;gn802N}`d-ZuFjq z)>VYmXRM*Dw_{p)!Uf@Ft5FoIQJ5JB_XDz~6=AfO<_!*Bo?9@EfZDN_=MGFnierQ& znOv*qsMz&@_u+!5*+YpPN*fW#}hrHcXyR3{L z3P`D&Auk@?7REB<9uk~Qc6W*>Jl_eGgyRl2!!i9hh;8Y`jd-In3rhog+r|A*QdmkH zo9H72kw3cm_X}k+N%@eFK_MBLdqE)qj6@}O*8M&QQ^-CEcKiq2M~q3|ycgpX^Uf%` zFH)Nuy8w{b&QPE4Qiq_q`*?3b8Bk$sU-T<9M|RV#XEQ*8@MSR3If zwk7uM?N$0cVmkoLpI{5X{9zjeEhla|7?`DEZ7Wr+E>H6NdPfGCSTfRqoVy2m$F3~{ z_vqpL^CGG0?DAJ102t%dO21Eg%=7k|jCNmCM@ zr{M=xJpHz&;G0UG-qKBr)BN+Y`&tQWyfc0tzWNsRMoq;=pO!LnNuYXt3iZd{t#6_# zJ(C@MpFaLj@nn_pxGnY6IAn_7xqJLGDXu?H_r83l%#o`AefH`>&Sdm9*AM7#1 zm)2@`O#>U^f4xMz;S`5S?T{v9K2MkS@JED&TlyJ@utpAE6;<~9iJAeR-CoF<7+&q{ zL+FZiL8}#k-a>d`2W&q^dIEZ84iQz~kPrhQ2$MD*jmD7XR~NMTRif`(VqOh9-E>RI zwv0zqM61v*LP_)%>eA%e5h&$HtN;-KC!9SaluQN6shO|k} z{}B$fDbL|(={GGJ8 zc{;7|#n|@;qvct5EWr3rUp}`244(Z?-w<4FTU}q0FT9p+i5Ufu5N0@8rV?0Elf%rz zL5tf^-sMTt*r@|sR&osglrZhrx95MM@~$0}|8G!vd%+*5yw>h5Dz7z5Swn^dpz>sd z04m=Ge~Zc+N!_CIG2XYRe6P??R9>j_{~DEdrT!O{mwE9YsJyokL50!_QI3-)GYT}P z45Oy(xW7#MIuf1^P}3JGS?cJH!vRbZ4*ha@0n~O4M!EbhRA56(lQ@wAD9Dk1KcpdW zgqoV@;{Uyo9y*3UfQlH=v`3b6eUtlXr)>4Y?>UqR^{%UoLDYQ`x4Ea5Q18*0n2jQ~ zsZl2E;+8*s&dc;ekOEdHqbZvxN^(FV7}s&bQ`X`FOQvZF0H0U zM!s@V3eLmw-G*I?k}hJDI;ROa7IzAsEhPrLNwj+{@_rss+M|*$5P-M}%%9lnLl9op zftS40;(pn*%y6eub(lW~l?X4B$|C^&xA4b89tyJFT@fK#V8#^AvUf&U*A%u_ZD!haMlc_YM%hglaE5b0u+2=|m z(Ho=vit$^_uGT)@Bt8PCAC#&(z4{Ri;zrskxbMqb*bON!&B1GQa=*a#j=bYgDg+ev zk^)UuRt1nyiYtx(G_Cvzf}qkOJH91*TiOEiHOaPFgVOl;||DT>uoQ}f68Lm?C6)`dSIf$_Q2 z{PCaqplsPfqs*woonzh{DKj`5@RdRhagelq|Io7>`(Ia$G8oDqh3w97q zEXGRkWtw=EkLoOg?8TeV-3G<7G5VrVlq*y3`aTUuIndG$O`wwn^Md1{Ra6cf9d3^K zKVKV&gp4GxD*!D$ffuBi(bTV#>IwYAZs-`Lm4QdYfm4B@rf4EJEu_h+8!=IW-leRj zKDQatHF4S=5A*n~QQ5W9hP6R5y;{pw$gzu8d>U#?=$!kr+7EnYHI>j4NLPgl&bQtz$_#eeLh$nibN=oh%H|b)-;(0^cwsA3{ z^;bw-l;2CDFnx9a0Uvt#!K_?Ttt7{+oF5UA`y(L-4*nAQGwO0-jjfI{dAdy?;nDYG z?#0zE@fPclxUzK`tw?${eV^k*lK3!`RRGi)2yGz zj5!m%9$jhm7?tb&b_4uRQ$J&O6)-k)hI^oLpyWYf%B!;R$yyH0Dzf#}7|KL)C%#(gAV3&OgA&u^6`J*$JN}~avGL+iypr=J@v-|t z9|lb`oC7Hm&HF_yGlKdF@wU)%d{Y19 zM)`9MTZwMFn!W@JOH`3rq)X!2TLp$vo?8WmJV1frll%XYlh9!d`oPXmT+?Gi-hNoG zOhDol<--dt0S+9&J9HZzB~jSo)BmbaX@@%1qKHb;{m?hLCvn_kyYP=)>X5Y%;Ryj) z32*ZOR)WGi8#FIMZpcWA`}AzMvoAxSe!V|~@nmskRX17fd~_QT>1Xe~;Tliw%75q& zZeC570wIIfgo%(!*#W-g20d$~1+=hn*;?@^cgqH>@T2CvO}bpBVF#G)}KLI2fyc;LF3Qg_v<2#>G1Xe)QU2>0o{Oc zgCFbQxBQ6%EF$pb*xmJ+DaUD4Bi1Uc*kZj`9@63c6NIPC0ZE~hZw-nX2ZTwjXaf)@ z;Ol?$FO=Y;DY44YL)|Qvh2aG5CumS1A-#HNZM@U?C@~9-SwpYoxc!wp!B1g@-oemF zWCctGyW41`m2(Z&NT;dzTd{3&@E`34)yfp5yENE_`jta|`j7ruBK zZe}fOn#a|xSoBnR?m!ma>4H8% z=%8@_QiTWkd@o<-)Xr>6DxX=nVqB%_jheV41^2ejuTjG|Rdzxa*FTRh!Vt{B_! zBkDN0`3I{*wQVLVe3UVDZMKfrLf_3r?Hev)H~H%ARvPZ@!VVRkj?^8z-i9G=7w+2B z$W>Wpe*`TIk&hbVvw2JrdRptwh1M5`s`KlTEjpx_`%hFAO$m(}RISeRy6^N>m5%5R zTdvgGujr;N8as-dWQm-Zw5{kqwOkRt*C59bB@8JHSu0m2poV#H#7*R@{pyY84G;h8 z1bjLFfe~O>%=@*UMg3iy+oHa0BrrdrIkjbwd|*Tw;}^$i7|ZXK1OAnYR)CZ2=;thk zS1^l6uXu<7tc9v5?4zgDh>;Du)o^ab+x6R;{+pkraWrIBjH*El-P-$c}@QGvp<8Y{XINQWzq=|rq}qfWZ!Z_eQdHWV%6_k#HMkhehr%+ zl9$TSn>&WTq-^v9iuxW^Kv945^Id2GB6?UCT?Rp)@IxctC^v34`&1vB1;Nd!tE1>s z;D_mt9}2fWDqFU@iXY8uwtl2}sph_=^c+PYD{85{gqlP-TON#P*g0o`5-@N+q;tcT z!Q-5uJ}8v4|2bv>(1)$}%Tt6%GEw68%>j%b%X$YV&%3Dtsw4=U<)%g<5fv1#yyV}s z9X%N`Cad+Sdet&T_-?u34_P_U>d7rx8G*$b&j8<3dUy$(g!GfU!TyTmmb)?k^*Z@a z?kUr#3uRZ?vCrVi#Bx&uN+3H6srd?uQqF*CNu%4WtICuo6D`JiQD)MU6H_ zfA(}}F~omF3-u^fhR&PVD@S=96V>i>5oL7>X z+Fr&pB9362O<@%KYDs@dp9N9!p;JigSWNVX?*RgKg(Gb4vA``X?SUwl3hC> zsZwrjK8K&qFD=M*=`1OEYO>JwlNvBO&-L6qluT#k_xS6qJndJi3_zWIAgC`gOT{Lg zJQC>XW_-TM@TGHiPW)__K@gV3(BBXt+Y2hgMGRp)M8I!zl5)t`Js0F3a-Wpvw@DDP z%?2@h-Bo1hGX-KBS=A@3iC#$-Ln;j~%DjlNWoQv=y>91f?;79ixfn3vS@aW0Zy_3T zTag=Ji}Kb{!K{b)U`@%m8Cf|x$HYFXm+^h4x5Q!2Z4%;@)MUf%lr~Nhy&UAOdXti$ z1Mlv!!U&Hq8b4RXE)f-b89gWm9}cH=t}B#tBJrw3OHHDj#V-|>xcqU!4&}rO^|b8? z&`=h9+KU~8#_asjysFOleX;7DS8Q*zwci5;Ush*>ByT2p$}g3b^KXb=M)0`0B{WZ% z4iS-$5yyCkF%(T)kU1&b*&&{34rmL+0?25-)O&_*EFcGYDA|j zRJ_Nk4V#gy|Goou@{rgG0jO&_o6L-IJHPg{;ZD+hw^CwYyHZl24<+r`ys8B?M0&Aa zOdgBd9rugMCqJVyT?gXC7!>QnjqYTdEzfND`z%~gqCxVD6>jraysel5xeXC(uC~r` z#u|BnZ??GE&4MX7Wt@2)T4FG1zPHi4x;bx&)`&6H2uwLo;cYO9i&p%=)jf&Ej% zg;3|Yg|vc{xn~y!S@}#3B1H@v8X|dpJM;7!v9;P*PPpEF1(9EI0CuWLWJ?F;qZ55Z zZ)>byR8wpxJ4|YPtWQRdZDyl$v+W4{U=#_etI#v;P5bPrn#J~;ZO(@d2pzlK@F1U5 zJ`}#u1TOgYRTs*b(Rc4V43o4L^9Lz++JhJ|Xs{nF+3-WzXeP?XOh?VBa8;DQavF~H zm=hSe0W|+tKDn*5sL)EulrG{xHQFKwW$aRvfbz+2zAp}=84ultK3$8^OZ7<^;e}v&VB!Sp2;O6Qe`*RNfzLIKFmn!0`g>U(Fw&y ze*X4nuPlNj#@i{D7NAf=;Bxsb%3wuL=r|nVd6^}GscCGjaCF*E;b1`7dYAQuW~*r- z6kos#;YwkP8Rh5CHV$e=5{inZ;@{*%ZcA z09gn|iY;w1wEA^sJ%Q09;B7|w?nLiB(8+C6$R39J3AwbbsiRc5j=WSc<7;8HE;UcH6hp+_$g4 zQ;y|g0{@k90JR#Q1FMw6APg|rlP4+r_6t3qfK z$6C8H%v+BiT^yr87YB)p+Hji7hFwlC6NmhOAtZf(Y=@Pn(N%lM0Tj59NcFP6DLABHPE+qoL0`F6f5^sfj_%MH zzWPwPV}L>EK4u4(bT}T5L(KfsQ>!#LC%j}Yf@0}n&;v=-SkMFXR=o4Y6F`wj?@qjU zc+WG+il{K%=e^|llBnsp(VYh*avwONGzeoBtp6(k%Xa@tD?VO259>D-Uu+kaBV^gv#(Y7W&k48=(%AVNfLONjZ864K3w0c=z`sPW+l;j2YZ>i|VHmg~I<_g~hVuTW9EHsIjrj*SlQ;b28#^;qHNklsDU*)?y^+O2 zn)S4Xk2LEpjE)5AGc41OaqQiLYZ&r8uge+ocGTY)%oWm*)*q}E&B2@~fxI2GaOppI!F|VE2 zCN=n2JM|xS>4mo;X3yjQwt5nbj!NKH9gpgPU}zOXwpltrim5{n7p+0-;HT0f zEoLO6SiP^`7z0F{dL-&G3`5c!BScmyT~~EAYFfTunm8&>^ovMs;>t3!wsJC-Ud7q%J+sT) zgE!Gh`Pasy1Gt7lgV-v}yUHAbh-cDzB+%<84r$T4lfZo<3w`38#)&v3bH}f=$|-2d zAGxn>=pC8tuzcSoBz=h{7B`-Q2(aGNWZTXHc!%QyJ|vv8_42r^j`zXu&7wpdCm`&? zP`Z7cSo1;ThYC0N^1w1+3JCdYu&zhBe@o5pJ2F2(x_c;~3s7=5LV9ikZ&ESS59l2D zIOn54XS?N8p{;8}g>6OZ&QkKkMqNtHkrT(t%Yb9N}vCV z+4&#ul=Db0t7x_DYb}o7_OM|;8#yQ+KBqA49I_I*_5F&LoP^7rm6EsZb@awY?%sY} z8=UN0;_W$gC>D*FV>r*CVh%tH5g^U`&?fn9NfJI|OW?&~OVTWSffs?#A04HBqBi1R z7&0ot0{^F|uI>a{0!7$|(%jDCfO(_0`D$E(Hffh+ajueu(CS4@3LVV;1C6~HLQC+% z6gaWYf(N2`YUWw^WJ$(Zzv|;SynCGTu=-9Pbe&%UNOIs;%nn$g=3xQg<78HabWao* zdL%7-qA|mufMLnaBH&hG$SdW8&@KG2jEWxQfq;)lqw9tLIvOgvFfiF{{v^yWDv3l{ zcMAQ{$U}Q1OO9JMVDIdi_NC07!JPT^Ia4(RqW~FimCV|>Ry&G(!CN1&4D|t~DWk(x zs{C88KF1%uD~6$Lgri*KQ-b!dS6Y(|5oP!dN)4C60!&&qJ1?Tw`=DFh;ms!rWb%{5 zd&|WjU_zAt?Ko<0=s4CsTB)?E8wa zjI;2Lo0R6oz?SU1UU(c;he~c;qlGaI#fv z*|v93|D@e>G|=g?7Hj1an4_(%QP~v(K$eZjM`2zVFAI0>isYI5V!@FI62UU^o6++B zM}X0K5mzt)^f3SGco??Vag4Xu;n82BzHCtyGD4h*NoPgsXkn7IoMCeg%xPcWBT3=3Q^s4v1{b)GX}4 ztu)xT&-6k|muYYf7oSD0UBsdD*@*>j>O`(R#IGfb|Cx8s=lQL(>dI@-He5L#R$h`< z5W`J8#BAYg{Pde(OP4>erP)s%rX61kP>MRVIUQDBkHKEAvUWN6?3yEGdjfUg?Hb$d ze7Kv=i?CeG!rVa1-YSl%DvqWqs;Md}9`TcpA}4Huqf!?i1CQHIE3n5z`vH-Afc;L5 z($kYmn6yqXa^Mo=#Hc*I1_0P#7AYkTmUGxx_?PtZ1M6t5*#$yCfB3Iw2-HZ%J;13v zxto^F(tgY+!j4Y}Fw*I66IcUqDof47z_flVJQ8SI&*=q~hjELF*=>52=6Q;ODNr&; zb+a1oc{#_(IoS%-aHY<20&UI-EcRQ}Ty9Ia*;R)Hr{mI}0Wr zwS!vd>)wfa6f_*+cdcWt#+$@H-?Q!c6=}doo!jFS*p2&=KQvmX17Bv5S;;K4A#ph< zB9`?}bz=TcS~mBvOXKZa&@f~{eAGkT4@;O-H+F*<48VPEdT{V+VY!5)E8W|HRJ*jz zP_VsB6}%2BMkjX6DuPH-D<_~OgM2qH)(eLd6y}9vEq~fI<+n8ana8-Qx<4AQH(lX3 zg%SIw&Qt?uX%Q*$BUT5lmcazYz9>M;!2a`eK4NYeOW%cEVKYC}*M6uOl9cU_r+kRF ze$BmWbsmWESt^h|disUtH#Fb7B-!C@9+hD>rV2)Et^6eg0=*WPKQ9G?UWtY1M@g&e ziAKrW1!vYziE$s!3>z`z*{Fp-EAd?Z{0Akb@Mv}p3!~nh| zo`aT>qP*Y$Ip~r~69p^;d1TK|S%Dx9JAFwsGjDClkf=)I=?8B(7sL~A&ZDX}NSh;` z|Bw;+tqH<=s|h0cmnKN`|9?%86#QfNyzjAz{JJ%pk%C#Ul$4Z>)&X!1$bzaxQAek3 zU;Cp*u4f31Xslop01A+;xjZKWsQW@4=k43o037!%PZ}0MTril_7unBl&09tW+5Rhe zVKQ-?iZ_inY$7orqtQYxh(|M|ygRmE@Oh`4=?*HlA>J26v)D+)5x;)B{fYC$l#DcS z)-8KWfVcgE5;}+pI+*31+#?ViFBib4L3uEH&+Fcd968E^#C7mpLoWtIj1HzVLP0#R z?KTx|$K-wWNZ2GMfNj2{W2ge7!q`B&F&O^F1Wv{Lrl_?sbRYP9$j@gWwyVhcj||l}?^po(yQezY?1d@Rd?7ityrLi`-A- z`qi;PS?Zx)it*H1yvPF=B3PWw@&p#Dm`n?{+lkHaspy8>tV||Lb*se_4i=SO_uxsq z_7ZVIg8*61uUxO)z23EIg5YIMu)X`e4jVHBrKxtwi3`|on{$_eDdb#Nf|zKE8ku)~ ztXmRnp=!84z6vi`l#>ayUn%Y+CRK@_eh`-_{jNW1Hf}bGY8dSi zY)t)U2PYNgR|TQ&(Oc~0Dy)jkKrrMZ*^~zzP&%Hlx|h@}KMN-fbpQ2xVK${RNm8w@ z>e!Do=Q%LzXuhfu!nOe*ci1a$DRnRLejJ_S9{*=s4<`oeB7+}5;%S-3v*+dP7M>K;fH9%};@7*(j=vw44b$F@Z zlcf(lMI2EyQ?2AQTHv^)L-9r+lLwhAa=yrV@$AvhN7;6#SYFb$`I*za{Fr(fw-xyJ zHVbG)!j!{VFLNGW3>$YefTuv9<|O@s3<-FOO!$RbcrHt=U#pt9Q#)PT8uji_NLUe4 zHU6rkMflsMs?LrS!wLE&q(nqz5aLq}YPb?+ZN&Cy9Fe9RHT)OC8H})?OfHC|nPSZB zef$hOQR7dF@1IA!SRbpjd2(|-Un_qTk+aa<4)l~oFwO%LjLS@)J(VEjGQ>fDFaR#Y zc12t(f1miBbN+PFsFq_FR1yT}6=(}0wY*y$9l+s?E<#CHn)R|^w*w2PjL%MzFA7H# z4;srm21PZZWa9#&AVy6->dfcBG;mZd&Bkai*zXTJBw1CeXUFhcg>yWgneuvvH6r=R zV}rnYk%s+|*W?ti^VAh^;qb_iHZX`<&u6wDTRKI$w041pn2!n8R*bXBCIQskWna9h zhvFOjKEg>uAvqA zIO)oKxlhTF4IUH)bN(1CqZ0D|=k~(QZcKnls5kF$u)-xr!Nv}gf|ss7Zp@(e>%CIo z_l;R)LiQeDl9$Zx!e%A)TfLH$nDhs6S{U+1Ak^M3b_yf{VPT_SL+uXkP{e}B3*pb- z$z@Vu!q5O4GYB%JrB-3afCbYU|;!pLa@789+plL0~w};QmHp*lwgdA|S(C znm8{OGCCm6%hD_Vny<(yNst>RYZWyV2N;b$xD(u8J^3;cCKx`)`F4bl>#ktc8kaC7 zLwaU9h^Yyk@@=LMwzhThzOTsctj3Kr#MzlrX4J>%gRkjh$2b8qc=XQ(DT*=#$R6><3T_;v^Ur{@WJ z1ob?*l|{u%!9k4(PiX)kIaJT^9?U(C8qw!*vx+~y!C(#&CIwD>)plEp1yaySee4`gW8aJND*Uvkxr-Jt3Pj1@#-!n>AGceP9`tSg)uBF?f zn|tEx_}7Bm+>aj!0SSy5cWEkoiCM4|Znns3gPguZd{a6&FmPeEA2!=*J+-OkBF5ok zSI;wPq`6FLqB&|IA{-faN|)^Q43%iTZB|+*WGakvWTMU&5Tqp4H$4+* zO|;t-(tgNi3lWi$x*@w6CRQrld`|LUmezaiJQ4YeFiO@!QRozYApyF6fs2ze=ts`0 zLJ{O(VRq9fpTOOL^a!h{g9TNxnVCU8;M#TF+$#9@yf!d4&N$TUcfC9BL?BTdG0#H^3fz_cD(Nity74ZT$P zcHJZcN7*bjpGJhkJDYB~b9weg?)mWbgAhSxJN&}C_5`VS6;)b?i*xIz4wHyVK z7jRB6silq27SudJ)(N^YKb9~fHC6`wi`d~-s)vztM|EBW>ZO0XybF3@n4*@f)~6PW zwW~Dsorii17yU++uL`<$#~}Ffp*gOb6MB~OC_v`)WJ1AY<6dBIm40iWH`U%#2DSMP z^q@#c@>Yi>M}5)*!QfrJSqV|WAzwi&c}hAEqsZ=rt7eRENjb*N-6DAfo!2Zbs0#Fp zY&0+X)o1iwlEE=tbsTI)m^n8Yb`qBd+c#+z)u9VBqzk9czt#ELwhqfLq6_AF&OH#A8y&4s8mn1c?Axuz)8#F*>&yv+ zWE_(77CUu53m_Eri$HYu3ppReR>yZ7=#gN(e@-F{A8)5OKTX@JC>m%-$Q)(VVqHzf zb*czFlyzkhS@lUdft&6LSo2p+3NId?#w67=M5)Ekm2fGA5Gx;#iM1cdv+jn^QoHf4 z(&`S!$3ZeHLoBYNh{${NviWptIg6Z(PgkaHZi?dDB=EivIHyM0L^y4YSohp0uF;o2 z_umDJUdzS@;83V$`A$mNq06p#jU;Nr zLT6Gqj{sYX@HffTe3r{`K&pc1xoTL@89v{r(-A?RG($mpO2MiSpf2twP{ z>a@44x`Anm>uALjC;fh+!+?zGbe`dg`B{#ZyQZSOTFXau+6swuxJFjklzs}Lq7ckX zS|>c2ZLsjX?QnMzW6K#scffQFdb0lgbp&B4NA|AMaM%G%p*~Bd9|@%~!@qE6lxrs5zH^ zjW2gE2RQ1TLgn%*q%qar;l%?uhrWe|eKWoYJ*jdiX6(`8ELZlpB(ed5Zn(s%aK52Z zhOM9l&2fuZuJ=T_hR*NyA3y#2*hgi`6eIU@N|~2SyzP?Y6fVL}bbgvz zR*}_HG~x^08pB@~+W)w)+&cH$Qeo5Ejh5{TOacSM>(;CUv0xb9#iRPO~n4^f3x0@_a)F-1hOB*enEHYQDCjDd;TEiSBD@LbL%9T8G zc4Q~)`sON8&cYyMTa}hYITR%Uebt^h`MD-@LQS@U7SbNH^YS9w6Xrz=-2`;{Jioe6c-_&zNKFzvPzt%WSVK0iZXdkid>L(4#zu&!ikK1nXNk9 za}5KNG-JVP>fz{I6-s{iTe6)h%Zd^P&hMt)GrNSsX@j%$_5)VZD&}X6f>-w&SHrU?m=7wv8hWg zx%QLGKk68HQM&SvjC|ar5gm@Pfn-z$)=!mg3cbvk*xh-(rjZBS9{O$k`i*_eG z#pqKxBo9xDoPkshgkKz!etF|<3A&lhfW?|iPpy@Om!mk`qUeRyU>y)}z88W|36Bgr zNCa+0+M`Z}lfMRwFWNS01sBwPDjLE&^iQZyXBj2}A7~mCu*8W4yj~xvE-BouwmNm0 z$g!OowaHq%o1D;>aB5SosGz&t{RS_>&t&pzL+-sPszXQ#WroafK7}WBoABZQ8LJou zE}}Wwv)sxP6l>grPM%UVk;I7Fdi;X~mpf!)p9~}Vsn>@C8?a3%_E*E~BjmEtXp~-V zm2RyEw1V%=9Zxx*H>O z+*@x0iIurlRHAz)`+6!M%bJ+^^xYDfF717S%y%1!uH(;c!j3C1lhhS=Z?}{5^{EU9 zC%|xC#xBS;0-N>$W|anyjiLfMSX?%~@&uWSW+_tQ0j{-J4W6j4WoCU7U$nmTu$`{0 zS`C~l&ER4EB{<*RpfJyrLsVlQL za8D?yZ10dE_)OLiZ2L1L{2k9wp3RDF@xMQ%+eJ$a zazboJ4hn#vkRNQlaYVNI`)E>AHRepo6Qsd=H1Xi{%@R`=VRLz#)YsvXH!t=CcuF>( zu}{D1X5My}PKJn|sdVaWMZ~G?2G0^C4?by<$%d$|akM(xn@O$`>*CpBq@s+Wa^ZDx zamJ6c_?Ygh3=34s-{p~2Sxrnb$g8;eH@*ly)-!$F#B<894m@ldf=mXho*s@X|0{NZ zFK9nQ(er35F8rf@F@aJ+@Lz!i5Q+W>ERb6v#_u7iUHOj@5$4o59%F@XJkSkXc}K@% zY*DsiVd1Jah@>mRVn@tQw!tmR&k&De(n(oUrL501r``YiO>A(XZ_*>yWE?!4EEcO# zQ+45VTFrZna&yz5PkMvcpm1^!5l96DEps*P^(ik44 zQ=!*;w2MT!_WRRPd;8h>o<{yYoJ2;NZkGJSHaFN*naY!{e#B8W9aPLgl^#Q2C&U?9 zcVBb(VBn1D0cULU!4ze@Cl4wLrS%Rrjcf;%ry{r+`<@$w-FgSdSoSNmV|=8H@I1^O zb#-f<0tAOS@RB+Rq78#XbJ1F-48iTBKPeNo8vHT>WEa;mcF2FR=bW!wUhpheHH{Sq=fN2G~SC93D7Cf1kQoM zgz4?j3xlc<`;hbf-=c^eY!Nc>{k7sjOA!)uk!cw+R!XDv+hWq8vbG%(vI>76ro9!a z>9wQlv&*$MH1=p+zd)APtN z`7m#q3zddu)TEijp!v&Da{W8Z%R?YEhsy$7a+{ zww)sN6w;gCe{H&otvhIcYZLd#rAyqm2!0)|9HLAHJK%8Lv+@YQY@*k@HIuk~)OmDG zg7^F&;?_I3nRN5fNfJ!8H~*Z``)*Xfv$Ed_zO63>=+!TyidL+SM&i1?<~WQTXkL38{RL}_0f>N^~W^li&4f(40BHRVh@3d*BTJ~ z@5~kO7g!>8pW9{wf7@>$e^!$Q2~qaOw>7jK^(il;oyUJ&PwtnhH0zLaQdAXcy`L7i zO;S}ul`cSr{@s%}>u-l-lpDCsL?MqZjtgX6i)AwSN7bvTao@#@#Vl@~$Ku{b*igS2 zDd|U@aEkrw>}}(Rkq_cvL9hmHH=Ux;VnnR$+a&~TDeNDKS@h7Y19H`V&UkcOd4-h~ zJA0ez`d#iZQhVDO)H)he2HxB(44&p*KPwgdWenruG9e{gl&<$wsHG_Oe7IEqa&tJ( z6TBbe$o}(D1sEBxUsZ!lhkLDd(B`Fgzi`ac{9fuvt?Sc+5Ah#f3OGE<^$Ty};~JeM zq5h1`lVMsvwVwpb^v{(tptHYr8E+uC;2QnXTS55tsMEzsTwk_`)J;pINlZC4$wi0k z-dFod9WYOM?$Adj@+rhq^ILwkll(4vI1Vlb4xZrh1j`Qg>^~{~S3}zCZ@MI}=Tn=w zr1hzdLG5m?OV*#fPwZH#;B);{t#|O|We++N zrB=bZyo)rVbl3hkGBT9aRi^1!KpA}H#z`^ zIm)5PWZKS5@;oOZELJkuWfXX*8Qw+rzmYHtq6@vS;KoWjv43%icYWho$9qkGS$lDF zb2NAw-(SCda}%$;V9?xGbK_YpRDPCruTQZ`q1Iuea@jNc5ck7(Mp5JliGdt;*}$Py zup>5w%z!mo*ok`b8?P}lNk1tmEo?#~Eo=hWFKRXj>I3b}i~f-^-WhCd1vJNg;mwco z3!62VX;`@UR`ZjRe7?kn>ZrD}aj`?tX=FmtLB5TrN^M|HV{dB-?dYSEtx|;!s1DE=JYWgctekgmJD3=HoQWFoe#Lvd| z{|r)`vvq?XCdeqeBpt>}KgA}QFP1hG#6agp^u|F8ogr_y&eT!4z5Fy=Op{ubF6}U_ zEo*Azkvr}wLZ7UtuZfS`jcn-bTgxKRhznBOw9jOKUe)jLYWN3SL>Yd5{vV0)nejX^ zdUr#D#z`e&pQ0|{LPP- zPIsvJa5P#{&mHhM8VtlyE`3aCpc}XO=f+Jj#JLHc4vMQZwF-?ifV^$wn$eGnSnRjR z3RVL(%qBqo`n@wnE|&wTQs=3>a$C+WSQ0t19)?;Rf;AV3u@B@pMM^HY4)51clhs9j z2B-~?kbjO2RtTZN?|@zUCG~UZKDQcwKAHbRM;IvQ@BL@deqwBtBb&8uzgF2#R_4~Z zp?+cf=iXQ&i+^48%LAILggcZzoTC2c_?ms~qWJwN5%CzK)tEBe&wfR`@Vx#I93bK) z=)FQt!4pO%!l;6#sFXia)cZace{C+U>)FYOapqsR==`15d$S3a756jAP8oKwC`os* zG1rwuW$zD5Rg`sCQK>Wf|2!oq`9W_WW7(o9m%gAj`!u9+(+c+6|kkxr%BLKrO^id~?Ej-Ut*tj=7wh z29DA&1v%Wl#_wQ2shbfi(27oRi)cW=DYsojP(hVPR&_Nw&{Rts|B|}ILDnJIH4U4Q zD^0YNwUdtgO;9xC*8c_xFU{eEW1w7H2@*;FxrSu}5AFsc-mHwG->h`C7N{63vNlH@ z2dbN-sX|<7P4Tr{%$AviuXh#<$ddDspzRHhybVfjKSweA>JnimpCIElxf|^Y@jSzB zPYc)Z(p^ubhla;zU+Q!qgad3h>GCL^5;y;Yv-f~%YFWdEkD`E51x0!h1rZRDBE3s* zic+N`#Q@T!BhqUG1f=&ST_7MWAXR!zAT$xFAt2HTN&XF}=bU@*_pNXJYu4I??Af#T z%)IlK=XoEZuvV-N*7*wW z*m9P_2S$CiWhW}m{{qMV$`>!grHeN3%!L1OG6OHjIH5>~r5nHA`0~f3GivppqgZgt zruijAUxY)c*S3e8(=T1Q-1J|d``~ndiM8L#4=fgwS>wZcbmzx)M!HpA`hjT7Hi1Lq-l*Z2XyVSw|ufz}63JuLP|-h7*Xm8z8?iH-w8 z@WlcH+9i2zShq;e%_@nx^gfRzWe6&MY#3BP@tBfVV7=(&14qcf;6HVM`B#U#iC+YM z4da>;;MPpb&TS;U%1n&#Ect^v{l;m!P(*9@Cqqcvo|_v6cgg48Gvk^upW9Ftb+@%+ z>PQ!@fpPA6b+!3@;>Y$Mh^mR(UDjZ8r%+ILxp^gNJZ8>lU6PAr?ou<+aR`BxCpp1D zcYxg2)Z;|AmJ}6IhJ#BQxBiKb(~4cSFY!u9xYv*|r8YN@1FI~^LYc6*RVtl+oa#Z2 zx{yv}v~D@;3PF(X*UeT{$zwjv&qyb3o!(!IBi}$y9qO#hK_m2APAG7nL$g@OW~TAB zFa4R#-8_~v)2*Ai!{;bsZ4*__6l%Lk4T@zn-UV51|l`5bAc`RwLuxvL$9F5BS7uh#1~N-Mv37rL7j z>i$8iloXDdgcD9tR$sV{VDoEb{=qh>zJhZrwANjQ8Iz$`Kr_P=EC!Q9XmR60b*VG4X+ zS3?F|ZeK~B%L4O-@HGuYKM)!G{veTZ8Sz6GsU!C7v+!MDJIu#7c!jzG_OIO9Udq4Q z32yOocgQDj{91iM@xs6tKfk~W-I>7K9fut2>^~rXOxHb8=u_L8_6e+WdNZ6^e%^1s zGKR6u)Fv#FkS-32<)@(TV0-g7R{rD+D<7WR6Zgg*>ntl7GP~k2nCARF`(nXE#}9qx zUnT1l3#{{D^h>e?*>=Mwcy=O()3eNpU5Nd7-9(oJyK#&{l_p3?uQ(I7g_Yq?d?9mQ zdSZ1b=AMy5%!xNxKyOw!D7zmyExwrxGHm|qH-PY+Uhaf2i^&#tQTl^Y+$>gi|b=VG#+v{_G}TlfH0-oTwA?50}DLLn$L4{WHRTYl>Iu|LAtV zLY<;Iz`vA7Y}j~wwdgLLGMUDPJW~D_XaIT@O8V{Mb)~zXWdS`9d?dE>Uf-#4x8fg~ zB;rhyT)Xj4vW?;dzw-0t8+`fy%f0`cyYw%xcPr$=&wnf#YtqAz6~g~F_ddlvJJ5~p z>EGt@myggRdO_%)5k%eniBLZQ9r=_~mq_Q#CGtomofn@`zT3)?r8SKX6uRQ`Q)Ain zKJ6%OM7MRs2Ne2BWVThSDD`eXRrLB&q&YcGYk>YgbC+C9Nh=buII4;`u{%nVdO2Z_4Eb3Y4Sg4;hKud z8H?6UL?4{W{~#%35dAmOMBzJ&!Qnh@j#aFU_x}ks(N7&~Q9;O ztd=1vbL}f$zuBg%G4bzdcgFhFTFsO@xeFE&sISZ6$FRub`%9Y~-!vzuu577e5*NPz z$l5vQX`RkjCNci6Ec7==U)?C|k_Pj!u{V>#uoT6ANY^zDwe~0B1sgP}{a2@0vFIV2 zMT6Sx-*^=hi~rka4R~(kJavjE_F0Sc#6Ek;H&clJ!RVQV&s~xBIb7CYJ;ytIHT9~< z8LhWlz-D%*Lu;RSz-_EG)A*lWAnRf@&*x!#+#T!{pTI_XIMiU9+@uTl68qNv#@#Nn zp5ks>4d^Xk=Qjqo+Z`FLycCH_f16~5o@LD|t)hPja)9qVA;<*_qN}?wbB#V%{>1cz zmjb^d7_tM-;@P*Ur%0W6emdUG;4mwlX=?g5hotZK#S#*#PGj-`EtbbwzYWC=VeTsr zo9@;Zp#03WHL1#x^UcrlA^_jy=ez5)dnBTSv-(Z)%K#*Qr`N`m9aOLH%0GF-<5dmj zn^PvQnZlW#v3(*2M=3sP*RAhro*CyUA=6u%srM_Fy~Dwn_7&(5uQWy0B)un{J(gxy zJ*AbMS!l++JxJ?WD1lY3oS8#C0d!`cE&crnhQTg_L|pP1hjRi}%z?)~PUC?BKQ3;S zhGRbzZXf*;tI&PxWsH{LO23R(+yGY{-(m0cGb`Wy?+rE&!B~|qC7Yd3TudlYB z7mb0o_q%+1MP?MiT!awpGlI)dXF;xshb&MqD75!G0gNOg`xkB@IU8uKX{ZWI%HTa_ za>BqY*{raDsLpeTuZ7%8!^N)@0kmpiMKfmRJ5BpLY(I+hhP6EiJcAB z>Lw}S$4n*;p|up zpwQ}qD}S)G30Aznl5K+>zAZ7=qsfNzz;EKsi1xAgMt1 zGV!-Jbt|z%KQB76bUnn`wD6J?H_z_9^fC0+8AA=uBT-le>@=i2q`Vd*g27JgR%qyN zCcbITd_cU5pO!U2bNu{0GIBHBoso$w=CxuV$F}Q|FyP~LpU%u@s@U(O*|O2mn?naP z2EZO7bW6h1nRK_uF{Bsa$rDKGC*Wo?cnP?D#;W@Zcx$@ot2 zO*%4UkFnBl3WYoJoGRblb@PM6r!Yd^O*7?f8B=>(KXxIK1#?UdjC&73xY$gxm5X>y zQtX8r7kiE0II(;0w`5?|+E@tH31z6So?uJC7avJKIlc*COXAL|d+wOO;hWILE~HmY z7id=&|7roA@_$#4^#gwJyMvQIk_-LA_baDj4SE5MY1bihA!%qtM`t}e%!apozL-BLCWVTG?2V2E7p>yTtLgz#S+xGvB@8xHZU6V~)C24w`}q#%KwD+Dp`( zQaUK~D;0En_bms@4FQx6Z&CB?z%F8ryBK_4a=u7TW4>@!QuM~1;gfWujdO|=*Z-K= zTe-K*UQB4s*_&xp{+o?-*5HjT`InH4$4O)w|`KkEAL#5Rwg$IE0k97@mj61 zOwEeO;#3uks>uY%d+cqFnDyKr_rl2Ap`#b$cM)JqLNf8rc+K&Q1DD%M^ z%4X)yi!lK05+iLwPCYZ93TV2(<2R))Z!Yv0aeO>=Kf?~c3x7TicE8t57+H-zMIy_) zneP!snv}@^=;?Xit-(V0`M?%=8L7*7=l!Kt>^0@-g~ITDo^vGcy9t}&iF<#KmhvC^ z^oli^1@U>-uh&cX*!XF)Sb_-7$-LgVNVp~K-L6P*7;q5k1b(%|5hy2=+sLQEa_@$} z^fU77hSAc1q@1_swTn=YG0*w;WkP3{k?lQVz4QH1P+Dwg6n27{pD^m~Br}Mdb}nlR zcl;6u_d{pkFn-v5+$QdD5Ql`~{IKP?1t@0O?|2Z0hT<}CXxzb|{eH$w`KBNA#fgU%8GCdI6sGIv)hxR~kW4n07d>0Nm!E=YZ=)+5c1y8|V5}R8s%gZ?6 zw?l`=T?As1rAKvZ+v!XP$L(vZ85w#$*1JXHT@sS}@a+IUjIU4E+*8(KZHW}Unxpac z4>NxCK*@2_>#(-~uQUB7e6`$6mX#%rH0H+wd0 zZ0PvuFc|F~6!#i$87Uld-dU?~?|68Px*QrYSFY*Np?r<2e5I&u8Qp`!%mIVD2Mi^) zOPrt`Kh$%p1=Ta}Q5vQ(C)~^fE##SZ>Dw-aFTSIG`K|mV!UMO-xwq*YVC*ycy3!!cq;lft zIv-_Ume&jcm;pbSwtnXxKRkvi_;LT{=8RvSISLD}X>eh?*$>JCjnKOe2-wV8uO{=? ze$zjyd7I%J1p*m1u($Yu{cudCBt7%dq$c;MiDz$@DPP=Zd;KI*7tEx~<%Wc$kuwJa zXVytJ@jd2O@7~Nv-`oayHzTu`m%V<~x4U&qUU4p6w7vmc?$u^^PPm6+7(5IXH}N4MBZg!#X$24il}R0MUwsr1 z*->BX1UMycT1_e*&?|P2G3T%}bRLN?QrpVNN^BIJHXEX=TdvM@F6-K<|YH)gV`Zr}d)yLah1leX_je=-UR*lE8k)|01@q%VB9zx5XbO~kGpYtp$7gg_&+ z4mt`Orr|5yE8UD0%?Skf217A(@2Ot{)kUYDhR+UxD|MH(yDw|Xop$e)4e^y3>X`{V z7<{9}gs6T?H10fb!Y!oX@~~(CN~_8`oA|z_nG%pc3NXy-kEd38sbOJ-#nYQ4ee{zUDjRcmCe2<4;wu<9DO=( zqzQRB4Ca-yrSGVi&jj*SZLyT7yy#x!?yl&)i8pTE4@J*pOgA~&EwaP2_Obr!o2PO! zJ@fHAiW)V+2ZL|6n5dx+yyz!z*DNn|ZI;X(z-b>w&(Sn*ZDOlNF;*xv0=n&JbKHPi z_r~cRpk)Wc{W_QPPR@eSgP#Xg4%g}JXmJe9ccc9FGkj+KsC+ZtZ6+W^4So*)^!WjB zzprqUaEz5HKo6>wNmRkQ+K1d6^XSAo32YL`qshrSIOrKHp5LLrlF#wX6b65U_}o`o ze7t&?l_G9eP1I0^vLL^mAD=}QUIfm1FIeG5@7~$4MO+2TZabG(OeoM%aD`o}AVurfvcJ_2@8q@XJ0>sd{Mpq<)g`?3R@SW+7TKc2jb0%cF7` zIQPUFeR6KzXJ$*s0ka(~8Mlc8F78P8YhG}!L`lwU6;13VqHwUk9KDQ{<}aVFQq=v< zWd|uAJ}Tr?PuRKaUlNeS{&+z(s*0e**y=JqXg)evwbc206^C3>bdB&}qeLco$9Y&Z z-k|Q#+d>a@TLOVWGD*$t$ZO-)FEY4Ef;82Ah!?B9H`6RipyGk z%!nO=w|n&3Gs*{{$mZ{)Pjfjd^@zI12JfT-eGh!hD96~!PvWQsg4M0}4fnNEf&z-C zIoeyWDr{9Zg`^*eXGuwQI#VODerx5FQ~qy!q*^;A?6~5kL`sQ+-va$yJ?keGge(i6 zjzko_JzP;E&^;pXgx}VHc8`W+inQNUBnzCRKGA}3{7R$pd6b4kw3NYmf`H$4eYErO zrQFdT6T;Q8uD9xRx}v0F=F)BIOR3fqCneANZ62u5dLn^;ost%EE4j@@hKVn&;&fmW z5^y=DKnF?CuY-XO>fZ5p(WfD1Njst*IqM*o?X5S#QNd}LL+c3yt;H(s9iRykx{IPe zCso<<&F${!b4bFTES> z(Ii|P>(czym}c`5y}}N1eNX`kgE6VVHHOQ%SK&-(jSIG-Tp^Qz5|)Cdzvf7N-~aqY z;F)L0Zcpecwfg2#C>F%Gl8+RDS<=qdkbj`~8|Q4(9H1m-ODB|NWt$p|R7ma{TTi%I zla5~U>2vvfCOucvH}Edf3evjOGYwT##s*^)Z@pFL3}DICVv-fHI~74Z60Zx(a&7WJ zx%)7H%TV@Vn_#XflsBGSGNq{9r9>@gY4@DgC8CpwT99(_lm!Nbah{+WRFY{3%`%vx zxxkWgME&t>0;b1HwLY;W3joEHBiVd4nIpM|rT-|+Ch%ZVl@*u)+LIZOKbrvpvr$o? z;x6zKC_VFw{YMP_hyiB8NkA;rPQ_xO%rdPvs}uiu*3H+P!>Rz}GPAEO?tLD1;I=8xTD(p|A{TU8VLN{9BJnyW~dxaSBY(|t4t zPwMR|D9?Rg;{*Aq65Cw~DL#5sI*Rar;UiVkDN*`fAu~lgSb8O2BG_L4v!K~$I#LLM zbglepfxvuSKz#MPq8+fGR$93G3?NECz@#t{7fToj(jDtQGR=sTGOWM|TmS(J_qb4R z^PD=+e$9L(pX9Vc#Y4h+fzwh`vzKF#GF)0dX0Y!gc<~<0yV{#c^DlFPsnAO=g`UlT z?E!`3g2bx_6i$cO`I%~9Ypw^oye^{@kSmn44i#$uY6ygcL9yZ(OuFfBKZe zjf%`UJQxAs&E7L9iJz}VE6gp zu+#_oLIp}Lss`7;9hrtF3A*q&h+|a(|HTJLnZ%a<O9CohB=6k&2lPG44jW)F z!hMb#rhZ}4?RlbH- zx9z3|cahn?!*65H6V)AlxXq}-;TX?8+u3D>0sbj&bEE?=A3c4<1(|X*g5II!q~917 z;&m+^D}7uW9#7f*?8YQE(&pwz=nRs)%cFS)UwAA^gE0MK2^}6n@GXOtbIH3fH`nr9 zPQfpZ$IU{^vDGbXt*C}_rSHp@-n8yr77%n2f7S`@We{EA#*lifN;mAhT0&TK)#Fq) zjlWqn=xTxode^7JJIs1(VpPusRo`omSLdw`kw#*9n*72tP~S8`>XvV}_ss0zn@e*c zuE*&gU>i&gOdR{mO@8Y}@23YbQ=gz!<)1ymqONtuCGV(ROJIL&e*Hzk%ffqkD2U?1 zNW@gvU1g0qRa26=#F^SXvo3`E<;sb^niv_rgzK}4^Qo`cFLD9zY>To8Z8W$Q$%F`| zh3=4xz(3__okxAGmTp+z8-$^a;lT#1eU@rJjY>Jt47qcO^>BZfPZ63B*z(MHjn;i* zq4{{fW~VK|bE0O|xohIbWRphE>!QJMQx4FskG(P7p!E=ZbMJlc=uA=P;^ zke#=-tX%6y1h|)zZr93fxo$mQN^sKXAqMq(J+|aX-&8W4oNg2UDQ;J4lOb!nHdoe! z7H#9OL1?3Fvg5q-75AIxtxBt&dac{W*r$vH7EB0pItLa!Lrrx;Q09X{N|dU;(?0v= zEnu5(qhK!_b|orgb$R2vZLytka9p1cqfytP@KkkbMu4~+Wf$UR$(%Z?N$-&z!{_I$ z^7&|MqMJRzJWU9xGW|5TY7%p2x`5kbA&l^)?4j^r%z)Cc zE!d@u7+Ykk0zI1W+q-OoBwsRvry6>GgzeQK{t}NhGqnWTqAHUw)6Bb5L>}xPa zzoS65&1q3dbxN=+7$AHeaM70zvx#CaExGJBj&&smufv`&bHS>jEC?emnUT6Cft*JZ zMo=UC57B7T<%zN&D1+qa9<5-U%74beS*D4G&JoHbK^R^WQNqo_(D~h7h_VJ>XLp#l3W3UZb?3H zPl`b94_S7l!^9=|s5OR)a2?T-ipxaKaqo`8@=7HLy2!|;#`tEnh1v_Cqz{^R_>ZfTA8|GC4=y)5*$RBrq(As zHJnJf_L1<(Xb(BzIN%ojvhXwf`NEs)-41WN{d_Hi6uBHb&8w)maNBLtW?{}0DZ2(L zV$dRJ0vzk`R`;7N)G}&}V({gQ^ji>U5nbX0_9JF)ta$Fakb)B;mj%Q1#g&bCOD%j2 zq9&^0L>CuSnc@>AS<3@q8J*_4m2_LTMdjsH$nmGx1wk@8zp~uM7+tLMt+}dnjxf?D zwFuHE@$O01O^>+I6?4BFcvj>#eFKSpAziAbD3R_1{A$!)o(AP4W1W3RH!;?cAd$qNs?fI$M@C;jq%55TXcDmq>%y@ z?+%GnWumzXv;|m4A0$jGP)x^AJ6m7}l5b_n4h&D}B09`!K|$+(8ICaya1l=?U;=Qp zQQYmXbsAGTsgOr7T@ui-XNj)>d{@`bh68Tyn)J+g*|UW0E%F%vTES+C9C;5XsEOBx zzi)j+?N!y^ncu29P{g^fx}nqRMSy=MHo;aT;6#Vo!NTHe|LNMe3bZX)Rc^-poN@B8 zqLa{XCi4|TXO;!KA9KN&IDF!Y2TOK&d8;4NbEPmA+|$}s9_M^ouFDZ6C0I)Q=B=6! z@nm(NU3=hz=^01Z zCF)bJ=eGq2+szEZx0!IOu^A@kR9{`%jc1@9%BDPiO%)YC+VzZL5*ui9;Ujb$`L@#| zeFmR*EK0pQ?bOIY8ZNdy^X*_HcBPvPFx}Xm2w>>~4yFU!`d;@UOH)d>Cg5NdXeSq@ z=0lK9*PqFgr01%#ypGRBg|2w)`T8D$dWee{@%P#3nP7h(>YZ|fsl=8kR|DiXz$Vq~ zn;tL{?fD67a3L56D3SXbn1Sf+b|Dut@8hveJYfyh1+hv6Y(Z>IIm45WjO~#&IffIi zcI?g$(YnfX!Bce?MGEQOYl{4mU8dq}-x_0KDUeQ=MV@9zAKUXP~E8t68PN-*{D{%2F6gWSq7Z`6$G(p_yOO9`2VAGPN7` zwZ^fkjEs0MNR;-c5k*YfE4y9y5#vZ^u=Hp+MQ4;V@+t?HsP@a8Q0a{AJ|tc^GuLU{ zagoG^XOOm2=Xo`EP1#iSSiKq9N7|M?=O6(=N-7B(v;!c z9=y3sUyMZyE2vhT1k~*?qOHA(T^Xp~gs1=Ec>|u~m8hq^20Ycl=iE%B;u-hwKJW`B zNKJ&YZVFrMIRKX);&5tKnAXke#m~B#VlBArHa)V-h>v^n2!aG&G7wBXwcrR!L zZ*6IjU9ct2YT|8AN@F>i@)z`xN;wJtgDM2%&gAM%Azjv6u~WG!tq^FpP4Ac`2i60f z8L%GcZUF0n&TL>Ck!+z7vyNCD9bC#pU>G=Vxn(>E;#aoeI=0oDUzvSyT;i%|uDZGc zQBszif5lY5oG->_jD|=vcYSy=l3}|ds+Y7joA|RN?`cb_T@9+&L3wsQ+4ObJVir(5 zYMs96rUdRz*<7&IgOdTEm`(7ju&r~-IHyS1)4e+d|4l@Tgnk(gpHpwL%2 zsH&tWi%R;O5S*SCdm$K_!X*~zGjI$kX-jzg#`mD1$Et_Nh%lvB7x+nwY;QHZ9pQ>KFnoCW&xlVjK4&T0y6m&9L znqGD^vWz}CK(_Cfzq=nvYsv9^XcvGq{|c&keTvY@1#`MqDWRl_#de&Ym9TT>UFpt` zmnQ!RgmEcnVVq%;U_9vY1C<#r*Q&fR@dTqQh6;>oymptp|B^{#z3HyI30*bHDAlqfs} z8ID-7XYkzz->y$J5NF|C7x-J zb6N~QlJzw-Ge?-7V6x%8ig{T;2mbJ^{9MS_;FpTQxTLSQ1o< z85?{7AH*K**GXa+KDkc&yn~LJ`}DYJsJx_mdL*cQwE4*n4a5d?2BGK5>tf^616rw{ z(?)dI!`-y-?(Yuo@5(EMil5Bc$GRkgB|0bW;n zg=_(`l)_XiF!|HLVDv(HREj&`IVD=qHmW_xQ7iH7qt`xP z&rH}Y8XL(n?Ic6~iH8A({1uf?&aYPAr?o(*YmQbu+hQ&3A9AjUHWL1{og&T%;c@C!l#M=z}w*0f-lHGRKfPW*jC(BCzV+X zC+S72y~%qHGl*u&*|I6b{%hnj<84nJgM0~*pOdta!H=)`s1}8vnUI_8kC@UXNY`?h zd^06zIXOqi6bxwp1(kM>k11#|0Z{3f0tjB4V3eWaQ(bgqP0GOEYRC2C!QZ!~(wWy{ zjp{JV5KLyxj7G?&1kF!<{1boY*$EfM2|CQ^&s5YRA#2*723$KtRu{01@>x6c_pvia z6aFt(UmdBCP3OVySyM9pj+Mih3x;;`n+5(PJ4x=pT*jLCk-Av12IjlS6sdWZprJe1TfUHpj;A{- z1G-!g^PErTX>Cm3bEa8ZlLf&r#-2C|$*GPJD!P>c`HkBAHqVB+1k!HIba|m@jtE^A zU*4#aU61(;E^nV_tICk;wvzQ}GptGHFWZ=ga;BMClLh=~ChJ?|tnGJS&{1(M+HTbk zi0zX-`IgD$B@6<_9d1TSEGbf-f!j*j-{?QLyE%}~w~?jFhQ?oeF~CyI|8FrV5e|9l zOjsqE;Y=6;csPxKhZCY%g<&8;pAcwv5zCQ_#W44L!Rz`xxIWhR3bqVH;iEo*Qcay^ zl|F*WqM3;a!ICStb|^e;*crv9XwxFDZE!YrdKQL3z~(>zY^MALHfz50Q~wnQ1E3hJ4${AXq)L)&cbeXw2gNU{FVGxdafB%3-?S?YD099zp zKcFDQi0eCfK;mja9mjt?A7dQhBA)u=gzM0+^c6)`!jjDOosK4hv7@246pNLhSm6`PaGYw=!5xbN9co7{EC8^BJ zQG)maM0kJWbz~t^9u*lOSXU6*z`em9m*{2`bux#ysZTKwA7t(vMeXo<$O(mnP za>vB*=o2gA<{yBrjv^`@?=yw#Ah7tKO{raZD-Y~>y_zfI^|fjPH-b()n7liy_BC?* zMPe6>D}9g64CpCs4J>D0h4tUX3HPt(A!78gMPm` zO}*;Q#GgA@rSC>zAL-IaMn7^wA-qdhT@BdiRO~{3W%(z2a9!p8h;I_&`JU};{_{c0 zb(U6w?mDWGR*$03)Tc7G{?l0P}db#}rvraedCy5pWL7+LN855Rm_zfIs zhA;S-|7cZdE0M}6z{J>1DdxYH(Wm~VTtJOz%XGyh&O+M<-5hUAvGXbJ&6;dRanHR3 z@m$zg#tLk1uJwPd`ra0zp1^C z`IgDatLuXWmii4#H9N_MFY?vKRp-DT^1gSRhjOGDzi|Hh=^R}pTu1*esvE{IrcU>1 zPM^CHP`cwEff?h3sn6k57$R<&@j=u-(^ihLNva%X99?50HR#IDf9L(}P&QF{Jfl`y zAgaR?GCX~*sha;-nkOr9NJSLbm|dmb<$go1glE*z$_OapL{++$R%h&4jTLCDjKT;> zDGAxgRhie@1K7FB+7&VYbql-~=|9x1sSTQR$L6dcG|;j>w61_bR%P-Yk<2GkWok5& zHkC;^y)srfGa(^ZqVU!j#fvjVog|-lR`M~`#zT3+l)Qi`Uk_fe+2QRP{Y9VNr?k4k z1_|K1!sPo^Rj#B&*O@Il?_Y%A8<+m1(EMu9fZW(iNvj+B*1&-lUhd+ee_}sQC}(28ez5(boU=A|f_djZ{IqGX}%^anLozROn0ebPq3B9QJi{SMf6$PrE z(2EA zUCaamV_u`PG3bTUodKgi`HAko+S?5!>hJ1&s|mgX&iXn*P4OXvI#C)mHjqe82;rUy0^Tw&6_)>ez+7Z}N_ z&Y-m+LKVm()T4ILv=2uB}D&A02HDciHG>#sSMMzcqrP_g3w0~m!YiTaDlZlkl3CpX2R5A z^}c^z$ks^j4O>l?hBHEi+st%cLev|`JcGnjUc4|e@RyEAYXvVeV%KjKqjGF}CB(qH zqAMf{U5fIUNBJ6f-F1-MFZaN0NZd%ZXZ^e(Ieznop`3N|Gkem%#&a#!BX%r*z9hTt z`jg4mEj@7`1?fh;sI62#MzwxWKOUX3FVpO(MdK06&uu?4zLw12q1IHc^q?3tQmut-W{WB< zQ_|wwh}#4`K3>yT-24PaC)Aavk>JF!*VZnPUdO!pWtD2zdW{zRpD1a9Z=Yn%3C7Z7 zhM#4&jU<^Fnj<>PCZDTG1IPLt_mical`i`x#lwA$M+Dd=xU$zORfVGwd@(LQBp0KK06y2FfYi@25T z@^-3$$gLq#b-LexlRVXc=(41eER-D!DWGr~}7ezJgbsSF9bAJ$aJz+PWoUof(dZ+BBi6Pb| zD(FzFbGmXDqXOPlDc882Hf3FotoZG!Q0WY&C+LNN|IZPUjg8O!h}2q0b7{?zv5ur~ zR3i`~mGLZN8~3L~h|&Rd(~riRIqVCrfQ0r>yxM_<<_R9^_29SD0PzmJmi2@k! zgfCq`!;p$f8xs&dTxzPOBulTzRbj7E+4D9uAB4N1>^;zV33J$w`)j$FYRP4zax$O# zWb<4QX}@$vKW+Z{k^Y`s)^rr@k@w(DQD8k(0s!^)!^4~?p7QqS14Yw%%cs>~B~L+#L5It!t&(eH>F z22*4x^Nz3iLQ2eBHdQ=eBmBJi7A{jPi)lZ+z*+=a=}A>Sd0L&7m*4Hw(jKX4r`7N0 ziGgf_c&rTU(2w8yyqb6p&mJ|c#M<7}Dp9LFLh*m7sm4pp*A_f)aS8WMIxQw9}zAP59_iik`Ot3~FHJMGlw5q0& z$^Ql2RNoYpw!JudVHPUsxo|G#MY3XzLSF1tYmy`ZZ^xwdbvHvg6^3r@Haqnab99|$;J<3|-G2klM#)KKU;r5E)8dXYxQx$lHt zjN~6n=kT^!ndHzjIcWIut!-kt?`5xuH^;5D5NI)1XrzyNG$is`EX+EN0Y}K!=oP$X zt|?3P)H;RgDWTU&FAbGeC%r!3;9Xgp9tcvCnr`lzXn%0*06xtZ3cmazyD#D@BOnEd z;MkN!5QOz%#?}HjnsNIRE;*;Guf}azsQ;WhN^r58%^AZRRLC_0q4$&CM$5yrVD=%+ zJb@lV;wgQmcbrRSyt7A1?IJASi0>?3ejLQTmIbmKAuY)#*(KNQEN0Nw4ep?cNZ{E? z@?h-G@s_NviGD!JN+D^mQ1Q-nEg*5uS`)1q@8MGsbYxDHqIwjSHR345km|cv(WVAyu1bs=rmp=Y2@qnB z8K8MTyvOB=za+>;yqF&F#iI4RktgN-fzPUvL;%cqZ#V~_ff%ErzLO2KtJ<_V(A7$j zxVBMx{(||dCq5BJIP)R}J15@fRk7P;MA29|0k7wN2NL71(fANhGbS;G1tH(UuU)3i zCx)0CcXEq&^I+~*x;)OoP{4j?5(tf5D~lNG1=imG$&Iis1KbEB401vrwzUr~HLr2Q zP0(td_z@FFvVc#Hnx301V7bfBL?`gb6I6>0HwF*^SIfdY}2+)p?AL(Y{fJ-P66aS{R@%|x(MsN zJ@};4e)KU-gm`GrjscjTWIoX0h?R(3U1dUE)xB+An*?b+zCPY!L;`pdO|)Dm2V&H? zgQ0Cz@OGZCYd2J{4e%fY#nLlgRRx3L4i)W|B+Dw!JwL3i)*E!6#poP3 zNiM3`!W;n4gNO{;adackcxgYe6l=)o>wB|3w!fcN!njRJOnccD_G6b8pK7jTzQ>-# zdgPL?R9t5#MK{HiK;*3$49X}(XkZ&9*qvqXE%SrRWQKYOGVey>EKG$K7_+m027ekf zhX&K19E1mv>+lMB2D_-PW?u%hvi&N&Sq1u-3nNe)1^?)F1{xW(f0nUzvu!b}wBuyI zOqiQ?uFU0)sku}&@+_>pL0W5TGKf#NZ!p!?GKGP_hMWOMq{*tS+z;9naCGe%JYR*N zQU@}F&egF$NwZkJrZ=~|SHrTXrvhDy9`ALXVrhaYV`h0%fA*!K44N&Z3d+rNJxRuv zYbBWS#X#OsD?9EpPt-A~frPJeePY}xBEp}@Wa*js~-4C8go+33NDUOIo0oBe!V`__mv z|JzxiE(JOOB^CIOd?^+nUkY~b;sX!?kS~R32J)o@Nl)^nY=7lTfv>!6(=o7NeY8Gq z89mHBEqD`E^I@-Wx+CM&G0oR! zLRguX-T+zZ>Nknnlq9$lY>teo*#M`>%Asv=ikQRpj|WRWToG1!-qFn;E8nF&-#Sd} zc)-VAyiln-r`<=y6*~xL1fh6lBoF+0A)Lq0%{fZq_dUR+HSlRI*hx0ZOEuf%y?PIy zR+~wk1dodaN4u}ZTW#pdgHwK1iD%`~;VpbK^%?&1k*Dp;;%xAm9Cs#(3ODl}x!P4X zi$WVYkj)&o_}8h>s3JEyi!Y}+Ceb~e#y?jct%_NysVR#{)`Q?W-%R+bhq}lxN30f;=VuJk%_ts*nlNycMzCeP&Xy;YLeXpPI4t+}J-yzO5xLy$S zCcH~Yv^G4M(5(89ovQfdDZqJ7mc{Of>GGvn5z?Ba+W}k(AWIDeqW#2K!0<2RU=aI> zGuQ!IG+)Ge!+vGAFUpXimu(GlJ*cY1clhF-mG%S>6oml!Bnhy6g9Mnyt_ICjr76E= zySfqyI*_Sh6Wnzd2D2Vb|A-hJ$?|+!m{*$iNy}EqxPgHqNxt{GzJ&52Qm@LGAFVid zy;ThKdYH=&^_`pxR(@^!yiF@<%@71;eNlVVE&hsb`>6i=bGp_65~Fz}Zipcmm*-%C zE&`!+O|!3hLtK}yh_IH_1zcdEA0@B2JTJiH$z$j zu7c)aqtb7H$c-NzHq2?K(d;`zwG9`h+)p!5IwR$l3DY0ciyH;bAf7<;HgRITk!yT! zw3=1I=HU3gjqe*eGz|rY=FYT&cIqvc#4g0+_@e1*)1v8i#tZR>c5nKKV*(ZJiDYlK z&N{vl_Br(AL#}d98@r+PG+xg8B3?dxzrzY6WRxC=3;Vhi zxRm)Q^p+^+11x5FK<{oy_ok{S&k8`DY*eKPp~T0RF;$WT2;Sq8g;#9Ak2q@cJ}G%s zHMQA+{R+yxM4Ryu{MbI`NwNhMdgmGq1ThY|5i(TE;XAN^+rm7B@`WE-dh5-C8#aB3 z4|q%4x4N4A{B}Cq9BkXo*^B|-_~VE!qcFchkktE!=5yI|`bAE}e7WkP)!gIJ6SD7l zVfls_H`+ygm?=_|i>{S-M!_Ic?Noqv-uEGPqt)z1fke4J%XNAnQO;>xY{^DrHo1%K zWyW^uGXbAZh|yHAo;8>oS4}Yr?SirznE~k~_uT2~3`ch8NguypJjvKBO{Hf36}HBD zWIsc`*Pfba=coyHc2MTddY<|?g20HhU@Y3db*i0##6wbEj&$x730M-tv$!4UIBEn# zg8NaM6`j34m`xj+mpSfIbKtK|m6=Sa(Ra_+M2e8PWt4PZn1@t}sFQ(Tpd^`W3cbtA z;o_U4J$86|d$%#ma>gFJ91_q@f$UFltx*y4TjdK$u)~R1kqRImC%R)ttY*1pu$JOZ zr@0q)rAO@}-U&-p{F2upO{uAQhlhzvwU0SCceE(-P6kf-E}&lMxyG36DT#JNfLsBJ z(_8`O8)X9^-SRq-TA#YfYrY@+k9?DJG!s`3c`H?HJ-sZnmG z@S2!D|3HChwwooUKvskNX;y=>?z(Uiunj*KP)ce9N*1u~Z%pZ~jg@>K>H@Y%IP$%a z7?HQ=%dSnlUyB#NaW6c>tk%|?<3hI0Ia&T)UOCEj1|pT<9I-fowh|i4euprSgo<%h zPqL{BC>V_9^Q?)QPq6`hhd_I7FZx#HYNXN39O=#)o+p6i{6{OEuJ5d}b#j1`Sok2J zEHPWhV5C@stV!hmWADAAqR8HL;ZYG#qKb%QMNpE8WRRdBNLEmC5Rlk3L6T&Uq#%Nl za|S`0Op|kxoSFujBqBLU&hYI5oN;D;=X~d`b^f~Ru3D=EY>KYxs=fF7yied-4!bSP zVI;F@+kb;L`eLqxunNh@MvV>EIc1wbSN2k@uM5H*0&f}H#Y(g1Fv_zpB3;M0a%8Hq z{gJ{+CR^QKE+fw=M-OJp{jrO+rGe8ScuIHU-1PID5Ts42O4}*t1+L_zsAN!p;Ia-Q zgM;I!e1%r`cfY=O%T>T;(PXlh6d?eI>1)9I$gvTXS-HBPquDQb^ z`z+rvUhZp;mH)zSe4^P}%tTIpK_ojd&-^mMekB#w2Qlh%Q>G8MLF29)ugwD*Gu5>Z`F<{PN1}2ep$K z6#G`3&pYJF@3_8Dts<6o!mq}1Xw(q6*Kmio$CtgFr{_x@d$^>Kf)9H+e)P=pw63%KTI!Im;xK;mcf}>0cr#VjXNYes)$@*Xr@uOPY?+v?(J0*ohb+$~$e_ z5D&2J6`qS>QY9Cxb3Xxx>;gs_-xpMKsQbbII| z91qDYgyOOOd_j0#~fvaX}yMYK*q;9J0+Fre)d3xDS%VPY7gO^aeH%@Z&H9ZBH8|Ms7D-I1JSPRmNF=$7A2%R*&l z?X5309;}*mIP705jY4%ghVpNOGu~~%iqmfR89bbI2o-u+nBuIH69ebwRBpw${MxJ@8TmQLG?ak> zGfKqYxX9JY{z}?G-gw!|WHIdnU=PhUdzqM~9}$Y9Wex-msFuk|p~_&e3XvYw_c}nn z&l~ER{;9+Kc{`f1dEJh2{WTm6(%d+ys3w&LMo#^26Xudmm&nRwhI&74N}X@&roLY+ zUKC$$moNV9+5L^+98WH@vqC<3X3Gj$<4uQrT89pAs@Yg1#CPwf=a%oBou_P>H3yw8 zuB9u%k=KHVn=jt=0JQ*Kw`GvrWLHco0*}TU+W9tS;?W%LS-{d8zvn=^+(99@%$D+f z8<{0&cMo*CpHhL*+Po>3!!g}OnOtzlmW9Af?Lh|*96mux>KkoLceO_6&5QUVs+NZq zCUWuvf^#p*Umw`?D~C$+n;;XvWX)etzTsQdJ*ovOYZwZ7>-x3ZESVAI40FWcZa z5?D(*?;C!)xZX#@JHLM`v)@QDK%J}cL8tnwLOPl|10ULj`7vC|T6Q{a$pq2@Wip2f zctj(7q)L*}${O$Lbq2X2nBzW@-sR{{IgJ1K4WVl!p%?ThH{}y&urvBuNCowWjh=(| zbBthYF3BTk^>{#(M}*hUPr9DOj$v1v#bLUWbAe#zJvJOmgfTwoMK)=O)%2}IQExHt zjYN^WLYjrmk%Jct+u`+7pY)dPTwHRt98C{%w#wl3my@Ruh`pNj9K*PN5v|PZFeZ*r zhP=J9VQv5nQ8fkro!Kx5A7|2BK zvj>ossa`y@p)cZjy5SoJEQ-CQKHq8OQ~E;Nbx7_C_=fWZkwBVTD_A&R z&E{r)jBk$J7t-n~pnlqK>_96QjB;J)+28KEXrG71zqWHpN8{fFmNGQ{*;sji#Wf$a zxIS;`Sx}W2%9FrZ!z$4V;GqHDLK7e2?7m-8MF55gz*e;tu zC4xj0sN3Sc@eC$r|7@iWL0TtE`F8B|tW-^B)Fain+ zSvw{7z3g(v#Ac-|!R_L=U#mE$n3r)FocE6n{@N)>x0MLY`zeGpTZVN$JI{@d0ur`J ztXoTU&FQBo{R|Y*GbNq+%M;9B+d=7^1ji2tWB=GE5LgFo=%60wrG=#o#!6GuN2I>Z zp{97g%~P8+zRiP*$}IN7{Ux{ODSa2;0d0h5{r&3PSIi-L6aCjHZZnUPAHLAATeQi} zjIzNWXfJs+yU(Jn*@amX$}*@Ptgm_V)Oa797m&}MK5c{}LJQ98^tqASgrOk{qvB39 z>)@pH!AS`fBA5Cq0V%PPUGr^6fnuHexUH(;-fl zNfq8~#EaP8Ul|{{BNPPHfx-PhrD-ikoH`0@6yD16XDiDL$`HK7R{QaAP?e5US*Fxo z91G0qbS%;$5kYES2zIO}gzlU0tL-`Lm44fmfy7{gbqM=VFoY%EBLw1Mu> zlL)`i&*EyA?mX={E88fAVs@+6`WwPYd??{l+9sxh;-_9I+EG&W}mZz{@A)ky;ol|>Qg zNU_ecSncZ-YO~7;g?C36j6&+dOI)>=BH)6NE6XrHCjaSUz@PE+JYLVG$(5~ZU&*a!M&5b4 zVMg5|O!2}ZOtY0(GB|tn+=fqbvfESACX6r|JC`e) zQhfu%v1eus|7PJLW{W-`lqO?&!GQlFOBwa4eY$s`^%)>5rE z7qc}QwCHF*-L7g$RvK~Iw+N0vbZaqIU0>8(7<SQOyS}pTm3HAuY)lLaaXs< z0E-M7c*HDEGoJEYHx#*gD#W#(4@pG@ja#Rnam&&Rj9a+Bk6YHq;}+7|gPY4s>44A# z-|SQ#+x>oK!YMzqC{~oQcQ6&;l02HcHF0h_anaUQP_?R4JX?v<@IBkc*YJl?jCJ7; zC%)x&P&!Xf=)RKF)|pZ$nE zAHnGZ)}3yOXA^neGK!>9ap}`XMZ43y30iKwqNMqn$puIAwQ5z_Pb`P}v9eXk@+b+e zclEO>Y;wXh)|F@0x=wouzA67M><;d#*@@4giJF;|>Ne%12Zhh>Y${fCI+g_qDFCi3 zyJurZ^PZsIcoy!#`xkg{YRxdY}`PaD*3a|smZ6nMe zp9HHzmEDSsB}aAg!$l$fQ5VvKgU-C~u@@Gn)+~U9f*oUQbfV07rO2VPY}<)SM(Ri< zbMy;R13irBzZ#^$0c%o%yLTz6sdp53IKJ{d=b@DDDea7f58SoJK%JpMX_^2jW_Riz z@-!m1k9!%mbj5lI5${A11xrC-USKIeNfi;X0;~|K*L$d9FD@KW(G@uZe}k3% zRDMC$wLNEn9pHT6K1XA__tEhXyw+DhC`CN9>%iQ~aMni4cJH$KVcB@ck6rMax;ayg z99{Alnw}&nBbR}LEOBpO$%2=uaSGJuKRJdn^c>%xC1r{MPew)V(C=OvIqxI%@i?1S zvpwxKJCrM9NWfGoGyM9_xyGRACpO;;Ub^O9I?-)gfyOZ2*xltPF`wZn$Z(8)Mvxe7 zq$2i%uR!~3a!d?aVt6HE9GzyJf-VkH?d^ua)2z{O7m+-{Ybt}<+^yHw*z$0X5BC9W z^)N>khU2q-s-Ao|{~@WHvFg>+@ew;@>BmGspp4?^`T}iIT@+G%Qe9sbrh8G!fUu+j zIE8I*0H-hy_gKK5i4ye#s{bb$M7PjD_5W{z`mksw#833o*YKHCF46bVhl}L_hlE_< zkgy8T9dQ6%W%9zYLqfHW^K1riNca!>?&EW`EyRvTlMnL&hXh1{bz`@+f)z}pWc}(e zhOk=uI&esMd`$7dvG2M1-^;s|3T5^G!Bx?>n!5z(FK=o^fkVQ_V}}Gn#mz)D;E*u9 z<7(>Xr2030_7MSd(e%(!qPwW`L-wqj=4IUI2D@Cj2t=U zmlr;#1YaXg2S`f9F-N}C2rxs*!B#?2o?}%`QjYnc*{1Ry7$lGagM_>|V35FaY>-gI z%xOWY`+s`f55PdIIylDNO1H+g`s-%ESkcfwK>%I-zN@hx!LvDWYBy8WzwtuLBAdCo z5YQ&oMJ3fI(}if8M#t{nv4ZhqdA|b?$Ms{Yg`uv<#Y8MX5wZsE2#6dv)BUf%5$;bO z$A9sSE)VbcNkDv~>ws@`5#k$(9`lU~3sSh(jMrv?13^}U&H5~NzA=9-4F{+{*?%2N znSqZJY}Sl?x-)!?dM$v z+%sVy?#bag714(yeIm3PB=5N#O&)FULDQL*qY=I1BMUd!a@U{LH9WQsST;T1BAO}& zw%d;kSTt@vN<}6pRMvZfvi!B-y^PgWgLQo1cMyNI4%Fcfj{1se>~F`DdEKE7A{Y?` zvcQN~+qcS(Vuw@^|70i$K(G6ocyLH1-(Mb3g@R_!NCJ4N_QvV1{Cj^qgixwu6M~azgG6L8blGkR8J! z%ZT_FFwm&3pF)6vM*E_hq3YE?u7QCj!RQ?1p75Icok7C$M6iV>aE4?CCp@2n^;ViT zGAds3wHk}xmM`HYd$uXZXktW&wQwqh8aI6^>nW<65=#dTE6k(D!ni95;67UzefU7i z@{hN>#{Fg%F6cADt%blZ`;4%|Hw2Dr^C3yz^tk?tKg3R%cvrZ*ta9`4bp~N0{C>>b z4;tSEo2b5~N*VjvAETrJ&I0Y(S7Q(KG|ms(MUoC*b(l`_D^AMU|6$~jQ&}(o>KF5LOiH%XCTH5t-c)_D5>GU&XS`xJ zf&-*-M)Z(6EcmV>%_Tcy1lNZ9qC$SW*0dzo%W-NmO0VA-*wBi;dPGbjfrv?Z$8=e4 z7@Atw?b*jC{x=|E(%;;eax$O7$Mv0z&zqtnZo5TV$I*Y+C!l}rG?X!V#@%Tw#k4Hc zWBliYs=%kUQ0lLVM3Fhk&fcs+EYo?>zzUbcBG2A7hV<6`AR^t;Ci zFFiU(o_lU!O_GH6M8H$}PCam+q+iZ$p9Eta-!_Lt*M?Ta#O{+=4FX!aoXddXH4HWK z`Sd2yAk$ri7iyj~h;KX>{wqhtpJVQ;jzEZtJ&` zaUCf{COcJt=}OwrC?{|}d&Ye>g~-6hY1$0Oe(jV1c#w1sUJQB%ap4zQ;Gv#y-;X~z z^+hC6-c^9=fsXvBH|WTZdV`Mqs5fs1Y&wATaxN^jgDyvEONgq~z8__Rl=M z=ZOxZKl9M>zHHWsgA9zD9-~fC#$hY1jthg>)|6kQC0w%NmtJzFJ7_iMg(x1pLiQr> z@Ut%yw%{jH>=S~mz4UT!17_{ZsBEHU3m=>+U5`!}aspU8>e5EvP7J?y=e+=IUfq1h zvioX#|28UW>M?nkrbG8Yhccni6z?ao!~trFo*JQGxUr&xDD%no<)cJC`~Fa(Y7@|J z@x7gCgFtRoMmVh+LE*Up<9=~9+9yZtlOSG#lFKE*S{m5HOe%#(L?0zU^iff?%z%hK zCJ@o*K1B4n3K4yDPKZAD8R@@6L?71^qR)pTqK}on_2xXPG0KaDsgsM9i5NhZS4ey6 zDfu9xj~+zyxpGAGSwyyrhJ?|}z@-+$KWg%?umujaYUWWf+P|l9;aCgp*zcp<*UK#6 z&oUw`gB3E0Glb9iGh*q@ASbrw!biDtopWvY*POb-cZb-UD7}De5UR-l(0-#|gheiZ z!Q?3fw41)*Tp+Z$R#p(OZ1c?Tp9f<}r`)l++ zL88H-7~cwu1HGs375XsRk)S2}gV-=7c#P<%V{@|3U}Oojyu-VBZ{4}Q93@zojj#^s z2Vdq}EKcwnXo?NihKKGSjI~NJoQtvxFUbk(Wxq4ZyL54%x0-0WL;0GmIa=>nx+?jZ zBBJw`B>HCF_o$Wh>Ob)}DHnM@MHi6VK|cD>suKO1VZdxNo0wMw5*$;MLHUH0c0 zat=jFYLlseZm%&eQ#X>?28O!!(`dg_@Y0rMM1M!TDcvqFFxS}S{qY*?TJ1D-g>YtH z?gD|pSr}9e-O|c-KXL(3c`p-f0!EixMCE&=b4^|npdF?6hlk;;?%Nc46FP>nvEdsr z645Nyxu~WP`6*@lXa?)t9qZi622*}Vnvpx}w6VF~J>3ouf-AU#52WCOe~RHU>yos_ z^9=!A1yoUZ#G(tQT5D+G1Axyl*#8j!b$#i_y=-)VE}sR^^3XwAo>554<8-9u8TLEU z^4Qlx^Ll#q6WCk zYqCPlk-Z{BHPF73GrWcmq0m(?w2IOwmgvWL9N#JX-`J1*(v(OvC6@~3E|cbz4jWK@ zM3$%=38ZY36U*;w;d;OGUa6}foA<4*Ap5&{!qFmqMCM1tykGSQ*}UI{tg8hDg%4&N z*t5C4Om`_F){Qb=3h4bXIGbepn{d!VT#3(5A@!)I8bB52i>VFwy!M+)&$g%k`mTPq zS%V@V-!>i#2Nk4J4tRmuK-%jQiIcR%v2f5r>0!bFZw?hoNN7)ZpPlPjLYfPb1NR}< zI@`-*P2+3sk1+W|>3#O~4vU2j#eL(M^+FV|3UdKflB;H%02-rJ@~1k`J$M}@42U6M zVmTA^)Zua7U6a4`oEEl`1ha7j>V=9|<`+s3CC@S~HPQ%oiiEPB;yM+*ckvdqsZ!e+ z-tRtRGgELLBl@S#ho{r8z2%wUf6c-l>J1AV7%x+u%&~47U!qY9G+8*vSuY!k-8{%C zNIJIRDHz4(%e!!0f$t-Vf&WicUv=|qD}5Hy!5p0!0Lze#NTy!Fi2S9Fv2DS((x=;0 z>(MA5Hj~;McV1NL4u2Z%*BRDrl*HAW^NYK?_*vYr71FVIvYfKczndQ{%bM>k^rwno zm}By7#ruk~37{Nw0&hok=iU@Hq#SHB5Aqe9ymjTIjt;6Tc6+z*ZK%qdhKHM&f~h-- z!qAA=!(>+X>#w!@^}ZiN!tDgoz#QQWkPZ%&0O=q%kPZ^G?EvYZA>4QL{X`miE13%i zk`B^@37JsYK1beg7mAk;*45|)Gq>ig{WW$=5pr0Vnea!!K zTbM#pnn1uq-0BT7;_lYkaIdXC>sj#6%hRImQH-HPP6HCYDL@+lGSG+ z=K4$hYC0#;_cVfo)OR?O;MJLDPaSUM-BthV9tOpeLWcE3m<^;!_5+$^qY|J=o;lVe z`yOkOb8d>Oiwbgiy|KSxSEgFFpON_x2t5Rwg)~`5fa(MKW@C5!YVCOM_XYM@rXWy5 z#fGj7tO9-qzoS5GH}{^iL(?dEJrQT_@cX*MaCaAO0LFj3kFMQq`>;366x zyUjs`5Q<-6NxIxpeKqfSma2U@>w3H5Z1iX&>3tzDPoNa^B(ta6CnJ>&oh13b%wMb| z9do;lv2I)ibYe?%R)DDR8g(oc)Q5#1*dl*`2K=|iJfd0fiqc=K(P&7>?#u5x+m#NS z?-ZSczX0=y-`~qG^k-Q*-xzGO^7#$j1@igE%&P0wCK}d&hMAzb^W1hOYlJoEit;b< z_kp>=DZx@pAO-Oz2t4z$tKo&db`^5|#5-pXOe2|J4=Cq5a(d^G8&co+`ufV8DTthN zIK`I?vRYm!v!(f~upJk1Me-kfbVT`Yk`f6xt zn5LY4eC%#pD*B;6Q#aG1RMU>EaL#{q+{Ve=u1G@*Pm_Xso%3%06;q=|2Z{SBTQ}q) z8(eUF(1;j?6bK=r~ssG&uWfecZ)Z=D-+ywHcrB&p#LBBm^Mlg`ynpSqM09`AkZeg ztaxYR2R03#4doIW9~-!MsbIW@S^|$W{TiFXxf4S3LzjFA_|l;1%ml#K?;d~0ACEh$ zNM~kOCOE$ZRW%0|4gN=v>NQavoZY39vwM63DV&#`hAvg1AP}L&DoWA?$S}Lpz678U z*Ri7m1cL(KO5j{6&(YY;slWjfiQt@K-*Dzy#XY`G;wRS$#n5gbZGw}&eySI$seXsO zPCj5YOF_C4>y4>IHQ3y-p3TN;&VT=AO#zixtu#Oh1GA6KnJz~y)?zhtHUr@6NoG#` ztNq6}h-I12T=M|$i|5z-T9rA{^v=oWH+B~&r)4K3mC$BZ6*L+N-7^&ST0J+ zZfc(fsxH1^NFV&9)cMA5mWaof%l2OuwpSN+{ES39fQ@JNBp5|pjXbE1R)Zgg*1Q1r z3MK+WbiZ((vq%<_{l5o>xDo-?&2xI&B!&3M=<=@T$YH{v8(52e6RB+n5gh^V)5I5PwPmm;Z?0P8B}mqv)pyy{X=Q;V%^l&jU`{bfyc5RjalF!9+;Kw9LbW^1lP~{(Q%^2aPZ$GG&vV*aGurFU*fZJ}TrJAMcwx9`~1`& zyLX?aV|Q+*X8d4rNwQ-bS1io_#^;#BZAWK;=dbVI+)#0fXTBX`)R;PKxZ zdu`M&Jh^{3{SMC9?y{HKVm~`SiU#l)vr6}h5GGF%kn=F?8=Y+wmPWd}T|KvST`c?J z->s^b5HNkF2dz!3N+lzRy736|Tm^Y&a(l5H#yF;A%N*NIKYuVq`^jAP>pYmPg06;#J4YyIgd! z!DIpGF?m)Cykw89&#f!J0gM{c~-kZ3v;TyT&C!>lyCZNGZ%|gh*Yne zqUGQ8HMa2y{yA9?j%N4jN^FH7_E+S|U1|#9jk|_yYoBad$*xp5@sEh(&#cM|@{5D{ z#CvhDc-#pU04e-i){hnb(-p(uHH2xu$wf=MfU9DyV1FJFH+Ya@>a^2Big#u~+t<_i zFuVRVY-O^p!{0+$$Jdh{sceXUdOqKkTwoptWtb5q*l&Jf$Mu`DnoVf9R?gDHVX+O3 zu-*F`8ef;eE^M_d1iM)7$~E1y_>5QYO+13JE2O*)kh*f4BhMfMzF>n^;dtc1Qf?R@ zZZuv&zM(c0Ydz_=ja-=GJCpi0fP`iGyFTe}NUFj1FC;bN7)c#)Ny04__nbGwVfqmt zS`Jy-xU?pJT<{MQyS5uyP6&^h!oYvG%qhM1!^F#z5CC>m5MXx=0CrUOLJ0w2m%{qp zzZ~@e@hp7hmBYMo7^kMqo$>?&ygRk)N}fP6ubHBD?2+MXCYSMD4z#m?iOv-Gi+?kB zICjYhS-!a{gI>=25No}coKbt*iOLR$TXXjHb}JDYv3-NC8;-mm(%+Ivof3+TeJV#! z9s3mX;RR6CFfALx=697d;yP0wuI?Ny&eG~?ZI28cww?45kfFo(C$IPtH2`A1u;Xe2 znneHM@Bim{QXqfMIQ`@8M;zY!{oO%13f?&s!Yl&t&zL+EHgU4tRi;?S^&R7OY~t9g z_!sX8Xv1z#e`n%4((Mq?{?hIIu?%!OAtQf$ZzUw&Ul0xyjFSNKqAabH$tkuF(Tzd} zs_#4?ZGLr9DChea)oeUVi_v zVR7m4xt!fHMvteGIyoJSOccYrUa@f}JeF2_^fo8bK<3*m)*5MDT= zxa(N++@y9l+qS_VHK?tnQ9qrsrnftCxUpUT9G$K@gA{M1zKLSXHTB?%<^6t3>xP5g zjw_k7twnXkk9Y@-2Scmzt^8ln7oM4zrJdwHV)@sXfriLjVb645uBn>0=>YCWNMq;; zX$+Cf8i;n|&dkotJ!5u5r5Q|b<3XNW8F_AtOnyY-M882wQeymuqrl)jFGd0Ze)_Zc zF5D{SWV=z@aJ!_q4pIgCty?!0B+qS+Eiw7h>c$2pvOYgd_7R8WH+^s^xm4<4KRYff zLP`%rhV-}&ZyE4?w{-~P!wo{OvFi<5fA#fS@`={Bjhwn(%pl3T^?0!f!X7OGhkiiV zV+4dfa)v?JBY{4^9t(^J%OUKM31E*ja$4{0E)`e}zS`SvU7{%d!vL}^OW@xxPW{A7 z36RQ2X)8=Tyh|e6+c1GvuKzj}uq_({wq;a%*SiUs_iCC&>rXd!-uz)_^ga>Dg3y4XG+k2^^WCz zuw##Qv5S6IVQ!q%v_VXAM+>-OTCIRuuH}ksC_}m9edY~2#iOtH9UX0ss>#b{#BYA#?xx-RLcloK-JP;)E2sJ#y0B~FLzV&A^2EKZCOmRxx7FZU z&js#qsrT3JL8f)TH{}0XL9XYbTIBDjNtWx*tVf_)X8T$W$Pv%vXjVc~2$L1A;#sx* zY2M|{EHKmeSm4NT4Y_ifq^p5gUpwsgs#@7gdG0G4g2!1P<S5Q-yeVD>kEJU zjDMTyFE;lynFKoB>%ZylbnkmXB65TGmQyVDMpGx;MWIm8FBp;Pzb|F^wwu@Q?1=s^ zqHXiu13>N$+Z`QKNuU7^{+yyw0_QU8HZ1t&~h(0y@d)A%hvE{cz3*4yR=7?w?B!)z*VIBFBG!K4q+JAt4hv=ULcUo7h0ThW<^|09w7P182uPS zEBNOd&^UE2`l@feO-2v{t-lR+VRw_KUv+2Zu?M>^K%e;&*b>>yww=`?Xn@`Aq%eg&wt}-?ci*s-kg#gAmxP7Eo+m%y{{j@PJM7Q@l@ZSLUsKxU#n`3~4y4~FgyO)TzMz!C%Yh$svk=P z%+|he0UE{sUbQ^;m9cJ3+r?<-314)M@Bqs%D@T_iIz|ognQlM;DCLqS40uH09`1SS zuXcpDZD5fOg0*pNd}}?-CTh-Jx{r0jUi#7mWXNw%*;ib#Ki9U;+i<=KmB7L+tKgg9 zpY|x{7`o6<6Oz?PnGH`jNRP?+&&99&rt~nob%(`phvKmDjCCPOATrItSv(6VVj3no zt;=xX_!cRho9p@l;37>Yz}FE(1U!n1Q1lZ14DeFpUwD{q#B?vTB~SY$&m~Xy>aWc* zQ&=ls;~;(fm#-X=ZQu7i1sveosCQ5wZIa;{L6 z2In6jN~4tVI7;Koo9x}YwB@^5jRa7X2GE-mi-7;x@UnF;%houfI&OoQx@+2JI@!2@ zXSTPZXS0@b)@*k2VGeMV^PSv1m&j*hK%ZxuG%0uWSPkZQ&Hip$9Ilr4>; z2Kiy@Ru{V_pI1h`VP+V$&-(3ylJTsiN;jI&hRRUWH8Pr=pdaQ|0l}ZmMZ;1IJyo>C zRq)sgGrLo#yiGUqyKc{y*wDHQvxSoH#D#6Mky!5bpO&$bVe`JKj}U+&)(jwWaiS3P zCBNY4GH+*)oUP;e%$B44wNWU4O?XoP{Je-7j8u)OKXw}hgeYkv$Y-XgT(B`SjZ`jJ zeY%^mOIuNnhy73xTYmp)DBOidn1i!4i~rz!epv_q0e)uVB9z7kep~PmM7-6mweuO=Ix zv@hu5<#%yTNE<|(0YrOB9-!mwLSE*kG-|Ydndc1djf#RGEV0ttkB;$wE`)}H zL!0`;Uh!7?lXu1)ipzP^IE!vUxLhz!Q&-C(AV?xEN(yAfweOKN7dx4_ah0S*&Ah*~ zPY$*clKmX3eUg1luCvpSf>WCbbSQ>jhl(T)*;8<#GQv5(aq29^u8(^@FdJ4k2Db5& zjRDXp)^%~tP*(GHWkZ`(7p+v^ldfzytlxmcB;`_spbprB#0EI)Cg?95Os-w0&Jxu1i4lOmk9=Qy__D_YJLL7 z^It)*n+c6t*u|n4S=^Sxu556EwSsZl& zj3w zxyGgTfAwyFp(LgF#%D~}NXL7pC24BVZsb$_fVVe>nl3V?^`YnXw zUg#>2%!`A_x!at;yLVOh@zh4n+3(X4Rv*6oGrEp*9thURxq6`6D*D%LWp$nSR~Xw6 zkzs#73Bm5i|H;+TCfM~$tDEOy3l3YPOS$;1K=-Ta`-n(Mt4FEapg}W7EflArdntd8 z+Y0tICB>gM^5hkCk?+(mwUL9ZgrqIUs*R)#ldZqs&Y@!y873yZd7%gQCx-1Mt5};1 zUCD6}o3%eg^gb7{4pP}(D)fj4$eg_5W81$-@ydA>_x!?!8B#9vIMs3dx?(+VGyAO` z<%#7jE}x0u^n(y zFUVd~v83)AO?j=Rr`|^QA(XX^E@k^xsN8r(hy|yA(fX-XT(#FTWVxh?#X5Y{bN4bQ zFBDd~^`|>OgB4SKM&mq#%`+2v+2BY7A>t#qy{V>wSK&kMLU-0DVyRZZF)HE6M?Exw zKO{3UL5%{97-dApj55q>rR=`lxpH#uy_HzZyIlzIxTrxSad2w_l6YG(h;h?*#vg`m z&8r$cZNStRuJOgNmJ}o-f2nIT8z<14`G_e$A z;LwH!6xr1m5lH9@cDFM9D$!9afXb&<@8rfBvZU7Z^&vj*K<%|N<-+elW`dbcBf052*G#3ME`;3<_q}o4klr>&J z+JMwGna24fq*I25akkC-h(QTf;((3)=2vAK3Gjha+L0kt#M$00RfM=%AU0FonAXF5 zvXK}X3zNDy$D}7C=iREPap&DSGcQ2R3a|1t&aHVj(5#pqDKC8R20_eFsAoJla9-O< zeLDt0+<(6M3L%OPieVc*j$w23iPu~Aj>z3lg|n`?X$?U!Y}a~@W7uR|5cm7`G+;1~ zUCQg)WhRWbZBSY7zhAwtsrp1f=r$UaW%>P~*s#~+T*5M4+g9#rM%MgCpLd==R)3sc zsk{2T<@JNq8JvNeZAyO9N4~xr$yOh!P&x;q!MP@OET-nlD z4!C&pRV#xlge2em)H;-%q?2`y9 z%O%ZK55B=ES2^xpaGTq~w$ugO9qggj^fwtAn)2p$eTyB{zl`&!K zfaLvR0+76GbhDg{0>ABS&Yd$Kb!vNO_F;`sIV;%MzdThPabtp`x$SLArpdVocaU>vLS6u>veK= zxIQt)1w47YOY+D0Vz`MLw(5tDM~pA|-1951z;+MlH?%cY!T#>V!P;(UzfjZW?|QltyrDwo3JnJ+n!j6Y@v zlerbLN%{2}Cu;)T%&FD}K)?u46OM}A^C(AL{Bg|*lw6BO1Kr+_;GpE9KsA~=vPefx z=A~F~hy^S~=H00w-)tMOblt_Q_V3uv@v>}MXdUdT?!`%9{ZDE z>Jodh!9)T_w^q@boztj@Jz6=L!C*IkI-aDrdvkhMwmYvO-G+CtF#n;!aOjSeIce~G zdlsGatFI|jvMi*qVIR8(bgYJqcSlIBu}XSqG|npcMfvo7XQB6W`w;z6rRb(7fkQ>A znPRoT5S@|C_p8DpTyjk5>@Rl|7iQil6rHsg&HJw6xCg#VkS(e=8_jEo=?%< zWeZL0O<#n}hLUa^3{T3;zA7|WtOFd-83FD|-9z3-RS~e&<>VlBk~}H%+vb2fmL)@x~E zwUF1{mAkndXJNIsrTLMKe3Px-=}6@;yxviRVY|*x3t_bjb4$64W!^UL;o?$S+e0o! z)65t&AzRb3Eq|}7V@J^Vl3qHMnn@nL7Jj9;@%I-<%MLp7R?$IB(+!Ms_NNEgq~K2l z(B=>3RTMmC&z|f5n15PvIosxw*W_N(if3?AJTG@zMxk9(Hcfdin-qxg^lZmV2@@N&U?Qo70M-upHM?E`^Ema{vXJ?*|hXtb=0CZ??TU_YPzYH~rQ zWz5aqRE&`pW~lIB-#m+DM$kxLI%-N{Jt_oqv$ssu7#fsj{QJ)Okd?fi2@OlGd{*%D zd;gzMw@;~Y4W|^Gh18dI^!&i7lFtHBDrC8=zYwde*P#uhQ@w@AtW*@Ty*NhR)_B`q zvW)>6kL2%s1xWX*J#5L7`OKdNlZ)}6VN2%_4$0v*D2=m?d>xy;jg^VMLSCxA4 z3zxE^FI)6D2DPMGXtfljdx512^LLZ6WN76!=`-^>1N^X|XrDkdL}uz~SepHCN^%^& zL(z@-ihx^>M7UOo_yXGY1U*emanxwv%Qop>?|XT8c0=pMp=VKr0c_uKX6|snrTXUq zUY`lY-Kg8~WEVzV$M(qay+%qD6@cNtOU~Q;s&bbzUL^#VW00prdS$OF^#FRG%e8m; zot5C{Kt%i+#H+>AlnAE%88{ODZZzHEr&D5j9c6uH;yp(J^XrcmYM%<+#@_^Vc!OZ`6~0a zytD42w7NEgMp4FnH@sBQv)_0(kRO%3Uf#ydw)cmN1njh7m`BCn0 zm*pup^LVnBUdVxQZ_S+UUr-uhh)N#b83<@&6c8qZ;~SDOG3$83UmCVrm!jQ%Y5YE0OVQSuI|rj##Z|UYj@ker zlM0AS`E;2g>!p)EVf%#^DV&0g@@s*Xb@S`-1!QdEUsCdzW|ii+iRA41o zrsy{zZzBtWzO92e+LQb==f}X}s<6H>>h;r_t!0?w$C?%0*_B85JC53LngQlF*<<1z z{SU8s&Ru{1LrDZw&Ju(?>9T_5jZ+`4vK5ULTP?$HA9Hf44vjss_Kio=&x9953 zskas%lxO#&=(rq(rj*x5J9u>>7M8Ny1asCwYFhSsjlZl`HuR;*>rCRek~eK$7#5y+ zzT?W|=T!ed^0YRcSJ{szEf@;nfw$F~G^)NAEN{TL8g+!A53mvX02`qXun~NKXH;+O zR$Ui6-t50O#fMZmXGhy8E8ynuRk6@SCW+(o(pHCN^JQzV$uIfwu?g@XuCQ-H7RG%FbxnLdedMe|6`Walb8P7EqZ>i8tDJ(~CG zlNclC<5xjDogMkL0lw3xNBqa7q+aggDrX54?29f*haa!*TSP4|HSiqLS zyC71<6f@M}+h&EHY$(9{geX>>rjsUNrALo`*cD!BhCcvYBQZ?l4Quk=SgK=akZ4dID=arTs7iKQmeIwKckq+cW2Rmq z@|sS82Qp)FmaIMjtSv7I9Ey@|J@gM6W79QJIgmJ9{3@WC@g^$ol;Ays=4S=an`|d)`9d?fAsd*LElKz_AF9OfwAcd zuT`MKy{>PJ7_=;3*M@sA$D7{#w6r(U@xw9eh)3OS8jbp$55JMkhKpD>%Wv06PIg9R zK0^;adxR|KYour-Z!^8rNG`Mav3!B~=nl?4n=-e+UK-fV-QLB~#&34NP2?>-05CX^puK1Wbn!U)IXxGB@Reru>%pT-oWJLK-c_cPDGSy1@L%;j zstw9XGhwv$Pws=ubHj>EH&|uz1wkQy?e-H;xcgnuVanopWDbgZO>~s_+VMQO`gUAT zYW1y=VDm&zQ5IC;n>tn9uOa;fdVXjudH=<(Zo!NeDM`_*YI;I^^>L3MroN~Lo7O+j z#wiIOP3>%3c!3wx#W*be&oBos>$y#43PCHeH;zlC13#;c{iMJX>iDA8djgbDPEy%A zyUibnrn}zIbSCC7@(ZdDtX$*f1dphf9MbXR5v`AC$?jhTf+q(-=n)l!9#KK?h#tle zfrzutxFx#t=<2%ZTLBOM_!@u0Qi%)te+cs%gFN zL6KR7!>B)=qNu;J;G_R+3M-XKeS5dcF|n~uB4F3PPJ-xLStp4OnrqRJ>zXcVUx#a& z`C}had%t`Mb#}~%3YjixjX#L}^d7(fzykJEIxe6njzHF4Xw_GMq5hp@2;~x5CF6t? z9YS$e&yA;4U?0Z^REi3`DpJ@NXprCE8|v@Lt5L=sB1s5yzxunrF9$ ziC^n`CnC68whDuTRNpD(qXIYVsK7-9v?G}kAukTU$@9Pzwp)00+^z(29g`$Jj{`_%^^jRfxkxtT|S)kFPi@0gsk-DbRk zO6X|0qkJ?Nl#h1KFJJCV+((cw_c?B2OI^u!QTyXG@a~COEKEKF+P()grP6psxG4b6gGi;Fsq@uW+APrU73J05Eex0P~~5XO{RqqFG{D z8}UjCO7Qr7)N{4vv*+-34A*iyk`dWm<1r)h?IHU6)$~)Vbt26 zLx$xMRH>2(w$MagQ*n0IJg9r(awou+;bPukov2QUf7s(+K>GCy(=tm?q767)VFO6C z0pE1W$k06Cu0C#;h;#qT(L!%{r=&_W!8erQV)7*lydQrNgnUHcGZBvx0jpy|jZH}S zYJoQgUM=!3oCk-`@;zI7PxxS;0>>n8pTe3}OP@l%LgpP?fk%aq_{pw3&s#j=v!e+< zj!2^O^XON*(KEe_y?HOypQjE9>Xy$29dOkTGL5J6O>9sh6{7F8i5EMPZx+1&G8?2u z^CVga?+(J z1jWrcgLyQN9Kp&{2*=i=+ATtIXva0p<8p?^a{Q%VFmuX905eaYcFYGbvtb`jJ_Ivk z+pZ`lMUmH>8&fA0;VFE-5FnQ7!5(gwpaFCt8led%vK4e@mJ~{(Frs+Gd~HOt7sHui37wa+#@{Qe&bElF5K_$5IHO<*k>&Rqx#~}s6Hwn z?!G$uup@ltd-A!~{wpZmjt|))-RR|x?t`_-!|t5ugo}~O#WylV6Q^8Xq%8t+&FrA5 zk1NMR@&%%ufCe~d9(BBOye&z7i3j+6Pi*W_Oo>_EYNv*Bdag*bj1) zT9&eRBz6ronmhH(X#IOm24kBvTru2I+qyIw?<~G|W^1CSwhQcehAVdX731Y2i>imH z8h;{83S9%R!8L`FaK z)pE?R&@pb2*lBlF+-V1iA&ldbndJLC-l-NseS|g{U|VTH6{ilp_xKE~yTDi>1jY(t zS#-L~soAnZZ8aYIw3+v@)(5fZK3n(f7=C>oZ}A*N=Z-Xm?v%i|Jcs=hp_oe6uiWRq#|s^6GN`39Ijj;?p;+1jW$#@n96kxLMg`Rwj*D1G|W& z^8T$~QG&+FVa?14na-Bl(F$ms#M!A3dDy1W$Y}gP?PcQQ!`_sJpLbBX&htI$N~Rz> z#`{Qu6G|aR?{IB6j}GD7byeVOEmGL4;@w2@FN7!*hC5W$eH=mc*}7QQC1CJ8J(E>< z{O)gFBsqJFas*(nd z=nT$2AcFWHNhZN!H+kV|1`)tY$z%|vG`!#kS6@huhCLT*hAhIk8 ztm-ToP2P4(i?}dPzIo1&4$``=P+B*vKo0C3A%57hRP~IaH2(6eqI4IAC_Z?*_?L8( zg&3F*W=MV~;8b3;_j{*HG|M!H?VTi}j!QQYcRp9bv)uu2>@UXoJBar%5Wcr z&zKhX4-?K32XA&)Mr1RptqbOCbY#?wiFc4jk;c5fq(jA*c zPI|u(8=*f;35VJQv<7)6mQf(=*sy)?`O2idjt_OEg|e}|U`9D7 zb=8+oO@Ke(MK&AA7iu)OFY};sVe^h^AM?2jZfZJA7z>lJ{t3guDmPD(u_Au-L0M0i zW>*oExgPLcJ3Nz$zh=+UqkeC+ME#yAQFMBO=q0%IS<6E|yauqp02w7CkWpfRGD?_o z8=G|dfy-)F^9`qTJVH76`l4*pCluJ<_*@{E?EsdVA02CRvzvBG;Mp&_Y@UUmEdY~+ zn9)t+)4EwY#fCpGg1hmSLg5duloFG2C0!N=dSw;qJ@5|9esIX^c46B1Xz z;w%DMoDuse&V*yiEiv0i0~iH%0Q+N^HuhOsPudFT3|_O>Q?z1Un_1;2*%_j!8!U~J zL+l84F^wK7?yUEZyqTSL9mH5X1Ib44;Cp>%5AKbADAqPht;@N~I&u4#KPigV_4Fv948Bx6O6*Kn^RqbsQa^I#8#pLSMFOt6aJ; zk)NsZ1?_9-(ysH%K~#TQY^B53P?-AAb6@zr$_a>kwfs%fd)QWFE>{{Pj7BS7cb?EV zhM9DeF2?o))LI;%UWLv9>Q$pQpk7Hp)GI0xK)qU7Xxn385cK*?PVa`AV9KxD=~_#( zDL@wj!94~$pR}IKC=9Z%u#DC4(NBPnIUhGM1V!poTpOH+@3LhCn$(2Ut!%S?*_VlU zjX5~)@{v5v-eoYagtL&nqxK`1#f%KcW&RJd*p{r3qXD(&XvuBI_JbvYQD1S-bsL0u z)$LW&_X5TCIHSxk?cHv~IlDL`GTXwrxaX&7=bKi}!PqdyS1F$%T)L9<9=2t@el0+htC$j-o@5+0LPTkU zOyi=pqtt_R#9$O0K?VZbgNQ^7^R?D}N^_-WS?0?Gsr_<^TDH&GDw%aCAESh*%tlD7 z4-a_9iUeuj|N2;F?Rv0hJ)-9l8wpI*tix+Ca3%l636=in*!~H?u~UA;jwlpNC?5h| zOVnA`A}cCzj?PsRTj0tR7EX@JfEl1mc*Tpc6C56bCW%!`bX@j~0_)HJ!#-;4W-lGN zwXeN57;sR7(8|ZQuTuN~ypaMnK45lF7EV$aOc;*qIGQ`r*geMa+*!u}=1!r}zNGA^ zW|QS%tCgn)9DEyhIM+?*pgHR0T$DkWaWuxw8sk-7Y-v+{_+bMRU14ZBzZcr)BfLz6 zu@NZM#*O2%^DYhGFYxM-A+WU{D6&|Bg(#_!oU-=cjM1k8al}V0Calz5ly)5v(dR)> zM{0&w2#TNHbzspTlxg<4;6^>bO#I96gL-oMl)o19_=FRe_e=oTQB|<&uG?Fz9XO}&;N4x+O}%Dp-=lGxzEyq zqb1CS^1(|0BC!@7Rmxu3l&*S^#z;8EGeCNV51o2`xTF&e(w1*-ZnRO-skKC1OWs%w z`##ldb5Drch{?r5Nkf;d^ZmkV>53i83<*9@`tDwyu<*;R(3MwhQQ~Jd0HY~7fG*8` zIU zAvZfh(Nj?=i9)=V?2(*#>4aUB3g$Iknr5SgZXX|BMlSJ#2UmJ)M@32tMQR@~quM#m z8@qJ65-f(Ub13ns=-URm0j*qBKo95O1Kz2i9nOIDX!~3&H05{KecxB0$J(R~TV9SD zKFsjZGui9F_|{>q(Gp%8g`Sfd^y&UI5W}W^I7`!6-d&$3dxF|*VpE!-_wBeK9*L;V z4_psk{=4Bmvx=Qx2B4&Xm^PkmAyIyFkl;(cXyb<*7GpBq&GCC5%P5@=_P&Yf#V_AL z*B__M)?>v5SK&?e9J-oKuJ0Vg%Nb>&0A57eYay ze*^BS86`n#r=YA{56p2|&o^$;KJuZ)veO>nsJ7tkzqXq;!MgNC&fWhReY6Q3ose+# zD`%gMX@}`Xz2RB<_NGitDis)@b&CIx5Ln+MZK$NR^Wzn|7XR6+zgDx$fPfz(WK?+O zpd15VB?E?N8Cy0V$V(ynv$}M%aSHw5QT3*u76)|7x9+wdM#c*6Fovlu$AYYl4y{Bcu}C56%mZho5(^hLjBVCv zn-2j90s9bu5HNU^c)Q3@D%-7$8-dAjTgsKkFMP{h_Y%l(6rZN|Xd!RE2o`PJFj$a% zt^+yPa_9;^khsDS0Vh6j7TR)L0$UCW#)!}RNFQ1@PktxgT3|wzGV8NqxPCb1Exk=g z)S%@g#jh_EVNj{TkGaW>VVfU(zai+I!~%5Ia{GpO;ArK(*-dYvd2Q20A{T_?Ji5CW zAz!GHzKYyRNVg;yjLN|Dyu&EvUriWY)%2=#Wn&LveKMWM4X^TN2pNCb?9hrJc_t%v zSvYH^r1H#;Y99Hyh62;g&&_NmB~+Yp3~{E{4aryJ7-|z&=i?-th_(hiR3if+r-R4q zkc{EJ$F5;`(JfFyGuYSY*P`R{$XUdz^6Uv38jjM?5*gHR!J|5VzRbi`wBdT&!Iwfe zUs+wTH1xxF3lyfMF7!l^O0GRvjepVJyjqRT#F4XG_|AMEruw2iqHd z#4nq^t~t$^pcE~tktejmKAhSL8dT})3-x`w)~-3Exp!X|EyAePuSJu8zyZE!qKgZe z-3cvUOl`*mmgO8(6ar(@B_kb{dz0VQEx_~m+TX5Gl)j_QU9kI1!4vsD_*I6h?e##T z;#~l*OFzAg$#cv{o?jAjPvpi4aS|aZ9yrsbebzpxJSAUSQ79?ZRUro?o0o8qlC2bt z7fhWNH`kj)!xSpqFP$UL-FX!8=1Ln8cJ8@KIpnrnmGDIUfTnv^>kW_muZ8!1AsOGl_n>Tm%b5Xc=yQ@lD}`ycuqJ zewf9Dyc>XmJgB0+^OYd!MhsQ=_H0n&f)pVx z#U7&-yx1DhRu&uuwrJ!*uFCe91efAov*K=h$*8Y(dDics(tit;zU#F#x(~cA-|X1B zTh_cWB+IW4TPAe|A}P?rKZou#OUAKJ!SUSiCobx7AS4tsCs*=zSXS&$iHxU{2%sOaLny={Pb;cUi1)z(%)W?f0L*uzcq4!2`U^BVpF z{m{y@UA)7kuP|LV3O{itFXK;Tm}%YnhFfm(b-F*{K4daFim2_^ygku#s>7_T3rO?g z?&Ys9cUct{GT-EYzWM<4)p9xcGixQ>kBpT>Z5J{DMG`d9E`jCwy39vPqHYli---)k z*~*5w!90<4)I}fbi_+nBSY-QxL6nFUj(0XK^kfq#P1Cbihqw`UPP9(0lz1%AY_3+^ zU!UFaIf&%}G{F2lEJgz@VLkP8ub`zaaTXqZ+h_dYf@i_@Xk)nWA?*9d1Q~->uaUIRcj@9L#f2>`Cm<$)RBtPq*M-idvRv>1B7- z6Sw}J4uiv#MgVfo;c0tbt69L}<@L_f5IBwKRXK}g&D78n!~N>%>_?sbi6ZNj(1KTd za)Mn&$*=&^nUH2bDqa&jKQT4Y$yp5GAD8XuD->cA8|&j^fk~WhZ6pb<^l`+LTP5CL zaj1pGEd;op=|iq((OB0r|6|v)BwYXr@t&scpX6NJY#oN_Rtp?DPe4=4bO@fEmx@#6 zhwaJ0`{E-#K>KU)O9p)7yyu4t%O*SR!1&C{g7R|gIYd}UX3RWWKL+wWgPA0Fl{!=m ztOvv%S)Q#2L;>Q)z4SQ`Q?&5yfAKv#*zCRzxt{rc@Q$_Z%wxOWGb|Q0L(x-?duOKU z{DG|SeP?4^K`}pZ$K3Z&l5Kq%8RJi_L=KB^)|5v#32+u#n|I;7_W^RFe8~%!I*odEflB1IOzoD z+>dI)L~op#C6Zfm%{RwJ7-U)IEm&+{pM~$wvzfQvl+<0jOGswP*uye5BF7A&3Z;u; z`PqTb*%7Kx02KHI`Sbe?Kh59(QTQ=M@Bu&+%DuG1+X$7jeDcoWGv#gD*N#`5=C&C_ zK5;#4o$bp{uuEOWW7R&DYfZv)I#{w=bWu0t9d3147sJC(w`h8_ZW_YmXm(vZeb-5c zF}5`Hdn)0Kc;t)2gep=i!Sz>@ph;l>IGcgz;XCJWx`8)F*#T7}AiaiyVc)v(T$3on zCz2vq5`WaCwzIH2S!%0uPQcu!*xvfABTe+s04}HhX^fT5^ZAw zEYv(;c^OJ_^u&s1LCHVEmi+tR{Wp-I8E`cN`JLbW&%~cGYIslWw$C-$H)jVcDFt**6u+g01jsMn6Y2ee7 zHF=?s(((uvM8pDMio4A#I6 zlXOb^$mw5miyY91x=*3yp-=A?8L)VBBI;sRcqo!#OF+MiK8&JcJunAEBWH+O@z(?O z#6tIUS_b#Oq3}BCKgDvzvSv&b1Nhvb(;jtD{+GKc4i&imyH6zn=BmE8{g*$J%?)N! z7yBehu6j+UdQzT9q7k)WA#aL-9a|NE1F5Qg_ zYHIqCPtw{NHRx3PYr-(d#;lrFH%?t;6PLu&uAT72fL6{0zWbd3nrQMY|LZdri<^z< zwQnFhGli^h)|%SzU3t&V$huz#L%xRzKMZ^i-!VrIM69KqM3nBAV>fJ={yo-M~FN)PxJid6JTK$2U(bPK^A6~kcC;zZwoW{ zxzFDe*bn&OCSmJ(6KH)JPkY;xE~6hqj}vure%$D;ou)U=wiFex%4y#nysshrQA5(W zxNqW4&%zIx_NVs?L~lsk*gRu&_Sy&Oj{+$)_1BkediqiR;mxLK|M14+R~p#2x(>fC zQB4f-)tLSq;`>~dgh2~bInJ9}2^90j!@o@pw+`@Y>+gybI07%Tq;me^WXpJY!%Dsi z+8aqAw*t(}Oo5r10Dg1LkOuin$6&W2gD(!kh)S_o_p(vspcdvV8+1(Vp7AsHLqBUE zwJ{W$h#4hxB)P$+xhs4*k5hR0weA;l{O{z3nrZymUWCtPOe$zc2QFL5_B{Eh@p&rv zbkw5p!Z-Am+XBoEDg>R)A4+Tm?}Uo0)*>R^K#CZfi7F5!mAJYYpl`(lezOA{MigSE zbj|jrwwm=5CB1puT`MS0RJBey_T=DB(z)k!^(GA`I4t-rR|qo?Yo{)+qxJZ<{$wY9od`@ru!~<-Cdv zT6^K-nyed~AYR_X+-df1=nQ!XU((UymO4fTTHN-y-!r@~sC6QwnM(eA1FxjDxITc` zi}OWL7Qs~b@0dL0F)ChJdfMXji&Gm~?fO$T9n{@A&4$VhojIk7H6U`vVT0Dc!a@yT zY@~(8Mt{LZQLHg=5`QeoJ>X#`OTBQm2s<_|o^`Z)R!3z)vcKt_P*wTbpZ|HiP25*J zm)6_e>QzNaH^>3zE$_vXDG~T)AZ}LrcrSkBspufB2_pU$CP9VZ(su$1pVxjHnIPS&s47|(42<4UizV`ftZ4`CBNN&x1{si*kbv6buQtHy?3NmA z9L;@fB-GlnJ|s|>L**cNqe_CbeCO%NtLAb0hL>xS=9Xj-t8K`JQShkQS4*z8(%P0uHB$VH{t7I51{<(uXH=`T z<@pJu(5#$|Yg_NGh8uGSJ1aNgREN>ZF@3#gQQ|+No(?8>yA(kJFu}957156jPlBap z!?+`eS=@Ro<}g_Ou?4rQT>wh3{RgsZB;U_=>e|8ts!3tM-LL=WrSiK*PLv;VudZHv zgKqw&z$rT-{bjmRL7)~SugsaWeSeo;|Pu8Ya$<+LjR)e0=De7g|@V8 z1z{$`?rsqtM_*^60$;b2!!`K!_$BmpR1sfvE797a zGgvy}X3t}uWzV1StS_ZFlL(`s!Z(HivspK8665)nb->QO)gf1adNXwij|I>_wJJH4MI9n!GIL=aA;>QdbD~u9p zx}zI(iXai~g5Z?!U8$QJ7eSfWI-)Lneph7ZCY@Ad0HtC%GGrBQ_^ZNg=20ML%JSUV z`0E3R`0MFYA(d6%t2=I^-PeK;^m*Tj@=mkP;PpLs_e52Yvz&3K6;{iA_Fy|91}YkE zy98iz#zZ^Sj^Crf#VN9Bi1V|71pGIZ=qgoC%V$bZ6~6^l{NHz@@W<$^n}1xnCJI|c zmiqjXr7eoz9vf#Q`{%|0r`h)`Pb*%DU)|32_lHc*pkoLTNpkv>v(g2>ffnL>MHE15 z_U+D99UgF$+JB_Y@0ao1->oa<-)qldX~q-@RNHIE=TC(Uhm;oP!6o1FMo1Kq=f(ey zy)Z#7{>${R)A_o$Z`&y}odfcL$JrgdB&9K$LQ!vH1J7qQU$fm@v=(OUe#n8e!M8Us zd`)Fi;x<06Q>xTbSLzLZG*wmJ@J)9Js}ck!O)U@D4?`t8(c(WLC2K)n7w88G6A;M% z?}Q2BzVukfzhc#*{lKc*8fN z*jlm-FWLlxgUU7BU7)oYCw3)Tfxsi8WB;-@<3M5Bg-s=gUvo>R{nbg-9r8K* zycO>4qZrPSc5vXafu{96y*mc!698obUvSdefoT$bzZ9@J1E;_NXii*A2slG3ET0GX z*XqVDot9SE*UCu%VWLaVJ8}0o8QemgZEb+Jh~C<5A-7SeH=_MA5V|GRz-4~D(LQy_ ztSbD5@W~@Gv)-_rtkB37Yx_5123FMpe#d^*(O05+ljU7qyg0*pHbAHyknpxZjAIIYwJzR_V1rO_=)W9?RT;cAu-7WgXo=N^SoL>*g8|8ruVb@{ z!^&`*cb}R-n+hi?KRXUSpyt1B+6HBX8s=i{{-Hly8oT*WC6aIbtOh+-`0tw%Nv%#z z5?Z_`d_SKk3k5_Gn7&_}n^6T~)Bru>0MIkZuL|ZZZjMS<$bf_6?vdy-f1Yj-gd^^Up*L+ z`eWe^03TGfd2);js3N=&!5P!Dx%>ji(EwbyDZqvE{Sy~%;byCDn{g4y22lN$4X~Eh zwU;afCDpb2)B-9gBVaPe!FNiM4`7X;lB$}EwaMU80{&jW;Y)R+rEgPp!=~DU&ytHf z1mK-Yf0OCE7==_xEV%&A$i!QsxTSW|NFY>#Kbq z@5V)vbH8c+Od}rs-tQzp^#H)q7?p6AuK3znSC?#K;wk`Gx(xxAWYGWQ#p@2{PrR4z zbRc;fG%sdy>350ANh{cTNCA*5p!$38x!)`Fk;)CQu-QEud+tbRLNGR_fg70(9STTF z1+*M8JAYwdRq+ZyE1iSTN`AlF)~QrDS52B)n%dU($pk9lbhWxPH7OpT8qoDyHK0q; zIA(4DI^c7!;EU;V1Db9NtRz7It%L)im9G3QF+VG7MJ>oU4WO0OOaomPScUj_fs{e7 z;&CY;J4vG;Nvu$1{g>UaDrI1XrjhBRK#~(4`pr1#v^q}^a6Nn9ena`9Ue}edXg*8g z1N)a18ZCpsv}L&Of=MhG6?s=|DYbZlbm?zBFY=Fu1T21Umk0)U;R0J@gh<=8AV}dJ#Ayalh_MC_Zsl`uP6X%#~aF4FVjByd)0mrLpI#4l13g zV{s*FDMo)ji^@6ZG8^3I==zR2G+29N$K12MrS$Xp(p!tQ3auNrYTv`xeAkKK!xUZO zdG2*>-UIuMp<7z=;_coeiXu~cx3xsln}TV0x|-^|_F*9^F8*vPC+D}OF2rqYOw6Rq-kfJcJYu?~tQ~U3fK5$gd z-ILw(xhrV!9Elhx18jf308zc&E!8YwUFnj2hqwgvU495kDuXuTd2L&ggtNy|lq6Zr zQTAjE<+0s|UN230=CJ2!lK@$srSJd_uWr^z58}KKkAM3wyWCHR^Msb??AhlxqQ}VY zr-B5sv?*TXT)!c|cAFADpg*R(RU$v8KNijuvto2W^4I_$B##a7LGl>9NS0*3Yh@G4@vSG#>NTknw5f@Kb`lQ9qj?w1CL#D}Uo7@wQckT1B`d1)c#0 zOjZ&2))B1-!Tx)B@V<@LqJ*}M;efS3w-hV&Nb5@?tdbL4Gyq)G^@LqR`vHl@?D;zDKVQEp`+6G!Ht4YvGY%i?v@)blLSZU1f7=OP#Rq z=jLjm<9NQCkT*^s?&{D7Q_WWRwX~z2OB%9<@UA{7U&@g-A4d(rcQ_&VPW&wZ-&y|z zWiw7r0r<{GPDjtR&gBJ=_Miv`oP3wcFUv8)hNB4IU0&9oAJZ8^to*^jm+2j(+065? zdxNLs`eDS~@{tU4)nHM*01eiiyp(U5jJlELuk#U(M^V=~%{fgUH%iys&s9K=*yW`Y zA9`j=o+ajnMf6uW7T-;liEG#Jr|mjof#+F{TCG~Up>{Xo`=xOC&7K95UQuBsV`Ufi zn}GXA1Gs+|awNjNzH#Z>X|Dn9-#rn7rIAbBXWqBP$EXgH6$Egj1BvxcQn3SYW5Daa3;e}l>ADJ^z#((*Gg%y zn{hs?+0Q(EuI~kQ2Qm-sK(u~6)z8W#=!%h_#%Hyba*0yacH|))ZYdAFO?WMKj2S!t zIvw?c5iDt+M*&T3jF?GvjQ6#UeYl__Y)6u7jpuTf7XXHdVnH9~f#%=4XkH$FbLW+7 zvj)y9<}9=1i1O}Bqdk?;{5>^Zvz;B?H;P)ML6fsISWvul^OwuaHA@4b_$y_+>5sar zrG3fwpB}!V?Ms>vT;#re4I;8Bp~^=VrEIxO!gRWfHRD}?R~G1FM>_)wm&vQVL=lL%+9}D7&x|0tt^2?WhId%#q!>bV%WRf2w?%KyCl;){ZVTc{A zCvQttOO0vbfy^F|ISNQB1++XeC*NjpRg2$c?gH-4xI<~o^TC%Y79%mh`nUywC zm}g6@)q=@)09*Ze3*pL)leuunb~OXMpY#+l9VA#IujoUjx^9zXR6a!DGPsvxiuJ`bVt4?^u3Fq3knAqsQX(5px4; za`sGY`ZC1aIIn&3q}Wg>wKv;x61pl)!v1lkkcs$vEzRc~v!hNz#{a80_UATazlydBSAT7YJ+9sTSo z!(`bDv$1A{(x5)=(9<)2srEi@rq!Q+C!2s}CLQJEdGMwF#!Oo6J2E^Ah+bszpaqJe zU5iTWF}t&;wJ%&_+2OjzGTJ)w>Ion#YQ5=u9g*c5R`z@sGTQNNAw-EMW%(L7|8w^y zt_Ez+uzo;wIvxk?n>`kbN#UM1lPRpi%Q4X_$6iDqCymTS`Fa5W7x=QDFdv}nW4kc= zr@Fq3Sv(iA!bRr~p7yME$mNJ!)H7W7P*4+#);T-YjJnr3wADo(6l?ybVq?z-g3Ol( zmuzn9UBatE4r@;HkcSLbKyeI7`emYDy{-19_@uoMcZXhWIPE}Z2IB5;VYxe>j<`FS zN8FteN8E%b42)BuSy9SOM_@Y)Kwi8QT0auo&3}JAIlNbPuTgyCA>etOE~80WobMD} zx|l$jFx-EDaE0`GuO(1MK4GAm3eAX8ZalikCUlXTJXGMmmSGGE60|8{m_VPbDS!&w zwFE>IwfD&A&@YZkj+^dv>^0$gm4*t2GhZb9V{l|E0i`R3Shn(AAbXKd2Twp`4}pk_ zgHbwdJoWYu+}SfGc-RlVz5#YQV2^1BF*IHkKw=nWg%7}qIpiIce%@Oy4$1x)@L;j$ z*-fwy8AkJj_int#h@^(FL!iQ2L_cl?MmWiuSA`R14Q36(?2^dV&y+c5GZ5*3VV4!) z;_pjUlyOIDq$;E-?DfJ&mpN6`*z`%@P_Vi;O?=C64yj1P>zyw8Fu9b5SN4+=?648`ku@yl(yE zBPwHMWWUf8#J8X8?iz||RCP6%w! zGJRw-{}&rH^l4^d{g1qUHxhbbSM2}RZc%Rww0W%|@WQ|PpmF%KboWO>M8Ii?2xtHi z0adX?z|12eAaFs84Fa@{(^6^P8vYOwP~!%c2$%v90dM{$0-nbb0sa3F0dGP?K>zZyO-Xub8YTu8`%6t?JrSkO=?tbmUX+tjS@ zT{_(pZv4$P1_&bi?&&BoC`a>U68DdjCSCmyD;dwB8!MT&juD-~veT6q06U$u;XJBf zsW%v@$3+|N2J}*bMkk(r$fEoE?rc0kkenqtz)F%gx|z6(-Bj2N$?~t;v&BnpgWPlq z*IQ~03}VOG4m`dP`j^fh4SMdJZ_^$x zHCrKhnq7O5?Jg8eNGXM;;!JDadk`n8k41+(kYZ&{YDYS{PY0Dfmxo3;*OnI61m9AI z*0n~u4Q}xO11NYCq&z=OT%BGUvum*sH$|10zdO*kXq)Yb(4N>A6#+pr;ak4H_c~91 z3SQpGMq(x2yvV{B5s{ET;g^#?HM52$K?uzOw3*7A=WBn za;CPfC*Nf=&sQ-ZvWTcFoY{F{2ZAOOe}X2w;d59lFDb+|MV|yL@LIA z(?(Rv2Qe>PF%!Du9+dJ#TFX8a1^9dFi?}&_U?mS8L2`rWc`um1s-XFcTL}J7_EUia z(C@VGQfzn{{$B3*S6VS&WLwD`2iH2XIU~c9s(x|*Va>k8*>8Xk9}oEO_tMlFVmfal zfv*^{KmkdofL2Bpu-l?7%WN|)?TVS){C!*5(pMm(v%fKiux4n)%0NWW>9>fW6Z3!D zcU6yUo?G^K^0HAK1ki3m0W_hnt~W2TZOB%GxYv;v41gVkF<7BHh+Yr_1GDW{d#H1lH1q?16OXMJkr(58^MMp7*69qyJqmTxbU4NT9&3E} z&sbw4%F*G$iU!`FR( zMj%15%sk@}AVW?}3okMkIuwx93TOpnZr8%#>fE3r}Y*4^)7W%Khh77MnAxn%ilcG+5oNYXi)&lodPLWQVW3 z94ZLN4i&9bJ|=J%WSq-X$g<`w)mX1q-)3E_shTKmFg!PLyO~HoNqyTkz}I=_NP6o< z|Fr?tSYMW|+N>Yp_kd1vR)hGZT~;`KwYSbUdY)ZuI85%g#m#-w=Ivtgq{>M_x><02 zyozl{+k16Mk!*QFcvoz6PKI(FT6-4k*()P=xE>@H3)y!lAC7OX9EUw+T zgBgzV2F=C?Yq&HAUM1?oD3E6->+atwY@gaj%7p^&|>Q!>$Vk5T|(239Q7@h_KY-6>N zeK<_V=toA`JX@{N584&6&*J#96uw$`TLpj6)`jMc#oc31kie#?AMCnbAFU}Ec_$E| z^wlPud_9l6$j58h#S_E4PwJMJhd@N~$HJLCWGKu7jwHgJst|y>S9@G-2?dZ6CWGA| z4T0Z0@-pUpLHVM>X9I*bx`3IDARDbKY`{)BRDYjzl%Pq+leMS<$CI^eQ7R5?pC8KU zZ7=T0I)|NlHlo?dsot}b51IHu55`lACxxB+<~fDglV!lZGPH#-7nxaS_aOq(;mLh| zotk3^yB7~K>iVv=RDHkVwKoN@v+||@c2?k(NTJsAFS8^Jf!t=gb6KTkUTiNZI0h15 z21mFBgoLoWQOCx(?7tVRwYt-O+1@X=o8#fnoWroLJU#jb6bR|Y8%anz+izK0SNzna}lapx3TYKLX+BZG)e~MjRp|{zx25X!Nfqq z%6E|SS(I+mgjZ#Pr@8+|$>@SjI2UK5eV$Em9izqP=z0EqKw39yC@`GC!y2DOj~Xk< z^seEmp5Qkp`(<5kzE7+S)V0B6V{R9CG}*j$+s~V_r1fQ4EK)F(9Y-Z9*!d10uA&Qi z%pD~>Yhj7<8+Bdz8JA}9)q>#@1-{Ziw*kZt)XuREb-RADIDO9-s}?b+K8d+a{5HPZ z3TSx)$2#CnsYP?a8a>-kk?ilJ)5s6PFP3tUScDQJ7BRvH4mXw&)A4f zWC>~}xDwkRu&}ek|8)B?!D(AX${ft>=!wboNEsK-?O%3Aanus8k~q{4dn!&gVF^2D zi2ow&;0FDju*1u%ahBXEY4~L77$NUGZY&fWloFPRCvZH;aIqDHt(~*X^9hsH&O+SC z8FshT@!gu%HYLN#gDpeyV8mVBW+DwdfoxRc{OnY8 z7$-{953|#b+u1IqEpKeF@?g4f*gyr42aAY}6jYknDDu#}SvVg@g-W7WFr7+z+x>7i zLuYf=-=qKC>^-6P2A+L8DiiP04?o@~iUAgAnMk|vblY!9?U)74NlJMscgk-z4(=}# z7T>JpZNs>HO7~oit@Hved!in6V?yao*X_NMI1sP)Y$-k6!6)qA%CFrFIeLDg!~*AN zhOhayrRv%Dr|KCKMW33M7xT5+F0O><@~O!xS82Q)OurA|XsxmB%w91h%p+i0L2D)-={V*nqe_~Bf?k=T|Y71b+5xs;l7`s-}e zWLy@FFSpwAkV!oI4&$a$zn1H+i^?@Bn!BTa(7o>Wu0LTqzjhRLJckFOj($d;I9E{0 zr;CgGSi*+G1IKCj>N}m;M4hB zS_a#jEtT&x1TzcD8*dlKx(ftL@J3UeV2It}l7?2=+OA4akZRW0nGQTeIVT$HuCf&$ z#0Oe$h;(k5bT`ll6_}1|zu&x7)S{kZ<6B#LYmqc|bxG<;O_Jz&e(%;0FH2*TZ|zQZ z!#gzJ2yj9B!feWKRlCR{sVn0#OQXnZRZnEqJ9LL&cWj07y`anI*yEsEd*_j?AQW_) z-0!FgjrRq^OuR413dH+X_U=TZo7*XrLtSI`$Sm%1s)TM>Z?eo^%Af0^R(wJ$oml>lt_ zjOyi7X#6?K%e@uSUNFmk%MR}@-Vjn+FzZ5nu7w8=wzh2FYQoI{zGd8&gbzd&S_Xlg znYIhz@0cb76w_q*6VnU?W0K2%#WZK2nC25v{{LJX2{E+~-tXF%B2))4%@io6IhU&T z@9QI=_$kZ_tjqSMsD2x~B?MBN&XRYq@N8$F_;*_~VyXDds}+TrR&79gdagPO zyh_tET=96xf!#|VnVLN^GC0-^u%MiDxizO24tQsn{CDJ6f_DEVgS_IoJ*j>k zMOr`El(|s zd;jL|rq5_-Mnr(={oyQnxAZ7X1HZ0@S0fOfa_gFS#x3)`p)k3&}t( zjS!McOD=A7>%G2^98LfC^%8cI?$$eSM-7h_y=^yG9AyxwKwCB@G&hwfKi52BntuTQ zEx79|pl7DS4yp+FkKU1>vcF(Me#YUCmMbCROETTaCpX*8`tgF%9F=Lv(0v>g*#jq+ z?iiv9rQAae<7kvBu1EPSIzq~31S590#iHwhy%|E|B#4!7V!@ikZK`KaoPv~V&Vh&~ z{>3)4L#w)sN^c-))M-0jC(V9qD-(#P(cav0@ul3V*cz9xHF($lI4uXR#)XwD>GcMZ z8DS_dNyynupY{6rvrMN-NO4a1K?-6xAozJx$A!pO+E&IE<66hQj16$w%2*q`YkPb( z2TpQykqGQX`d)Pdr9ELyd6Ed(HdB`8;@_c2>q&55xmlf7oiZyG8I>N@6Hzm*fU=mu zjO{KzacMVqq`r2mh>!4DSSB zaHh5i>%O#94V=x`%Z}{Lzy(?lNxsF#yr>P|u(-s1q?o4osgW%;v|6&?`>{l^4A4K? z%ZnGd64gQIK@1RFCXlE)jSy4R=Z}}{sq9Ar`60!$DwFxD8<1jJ1~a6X_SRwn=pp9l z9tSjY9jqq{KDyE~_QH{HpqBQAiW;3sf9}+q%B8P(pFz|k22ue`m3kA?$%O=hYTi}@ z11h>!;+y@N`xCv{6Ys^$Y)JY8_eo#PKR2{9KL6Ep_g2xjR%$9fD#)oKtN3}f_s0~q zf9_9@kRsD_uSSt_9oVJg@a$9qi*yD*mp?4(4VV89e|AOOcx8qW?tWn%J{{<4ImOSx z)>?;8T5aP07YU)6Tg!3FKjLQ}X{xKdsUJccLv%R7k08c9bdpuAvOvOtCLYk2`Zv!r zIlYI8h%dE?sjNMfiK#m};8nDIG#ljzsbI94d5mNseq1Deq*$r|HHZm zmrWKqyc8i8UZps=&d;vV0~A9Z2Zr4>v&v#tchNq^ge9l~Oqd*Gd^RB3S}v;VmJ3IZ zsczXJR(5D>V&y<(znA_Ujk<)?HViia5UiTrrv@Oza_1KZ*kIp>Y$$Ag2Os_kcPjPR zj0_dZi=e`9`Xdn+SZ(`rI2#uTALd2SCWr6`{6`*!2+G5Fx)o^!{>j5s|FYkrU)DZP z9-^U&cUVD_V_~@|3Vg##&+@G^1%=;3jO1g5%n$? zUmG-M5C=+LmKC4xiG+B zTDT+l1xrXJIseduYEGQDzrvPO9{y92gY~Uh0?B?7LWh!RJZRp)TCu)WHC=S z%YlT=i!d)qS%?c04ue&Pg}rL7`lEj%@CAiK``2Yjgt%{VgF6#$^3!|~0G;?37ygSz z1Tq{Mu5ap1Ky(3-Lhpj0!=9LOziAk-wf^Hrbq;%2wG|ZChT)xw>x}^BIziY1Ai~o@ zdW%ThZ87m4y=U?CCbk;CM85WX&nUz#RDzdRI1Ng{^*iv-5rXbwuhCD(m7b{gbuny$ z{|#mGOYF@1$n85_Mo`$Ru%(lWwoi3{S2yaz=LilihqyWT{~ghZ3`K^D z8hI}hUO*&M*YU7Gq3lN=a*1ows7;Hz^CQTTgN~;3zRQeNTvf&3KF0j&$z7*d-{L@( z5m zHzRGK5zrvV!8S;zN7d)cOv_ArV1{+L&)Kb7waQGfZR|OG-l`Rr_lOmK`rc8y z8DnSd4MT>BntC4)UO)|m)wTK^7+Rcyeg>h|Zm%hg1Q%4u$}&%>j{Ay5z+BT@6J1fQ zCf*s_g{DHkubA-&L8#a~8<(9MW}TkeylUP>IGa4Zar6y^nP96nt2XcrP>a;ah-^Wq z1qH%-UuKE6n2i0YK$`Zp0mihe)h)X^P&bklW4L-$6ff^ySO2eWB>f-VDAWpk6FOIl z&Fby|<9{}Hb2FRQ$k(8`u|v)6D*cu^_OeoJ?E0B>lp$`8rr9S;u;o@%lz*Dr zE#a_-(oo|B10ZOeN}zH6Ihkx3>KuQ&GVOm~`F7J$OKu#T&%(CknbTHBgZRX;GCo4AfJwKv!N=;)^T``LzXuc(h;vlxQSqOwRjg$ zdF;8Z&qQ&K2CJ0&WwLjm8~IE1pOESM4Haq7Ho!m(wT%}6o!sVZsBD6FIGWduiyiXc z6WzlD|9+G#%m_T|j-m)KXTb{i6p5SJCoxH#g znx@$DR0NBi2|)Ayi{#_f@b`t?59yu*^Uovd z&lm3Bg+`VDDO$mHQY7eSV0;Aqj6daS5}i;9Chs&LyWPiECKDcTpag`tw-@i7g(zwq zmH}9%iGsL<=qHne5u<_=JistXhl@Ufum~28$ffxNo+}Xf)J1_p>0kGC(6r*dn< z#x`b7na7CAOfnCpA}I|@rk%2*B5g@#wiFFAhLoX6lMs@bEoBpNPJ^KgTSP_1OqsrW zJzJ^X@0|C0|M`Be-`l~n*RzIuUH5fe_j(?IL%=Hy$p-`8IXodYusnhZxqFGgxD-88 zcWMkL2>&*(8w=4~x0?kb!K*-bw|`fim_lRW@*IX`3+p9p-2G6j{@pNXtU;GPL@_CE zw4NQ7AnofK#=(+pRR@!8q(q`Ppl_#GU?|yPTZ`-aUu;EXO~8HiXY!s-`yP786PQ-f z!nJs9sA;m0r<3@jzzl9d*BkZyoSh4BzIw%rKj8el8rojY*!JRo+%+LDAN^=w!n%F& z-iH*I!t|JZCb^QH`#x?v^a5M#V;Q^ev~$ps!=hoo5pf%CqGQHB8{Qml{mxytjRc)m!B=l6$X8aheeQ9Lg~ zm%WsLaLvxlbMfKvKo0tV9B?X5efujWPflr{LgQ%%;)BT>r(OdFBriM}b>N7) zC_I_z@?Mx>2}IMI(AP`_^!$B|FW7?p(aHq-(n0*Sy^A-vqZ*1;=A{hiF0Su|(et02v}fZh;n{fD z6Tdtg&-(M(c-L$$$O;2Q6>I-41#t-I#hOWGpkUXzq>4%*J@H3#+N&HMomcm6_sIx< zJ~!VoeXXr3dF4BSq$bD1r;Z&7Nt}t|;F^);bal0}`*!>9PwzvRmy8X3J0is|}$mV@Hl4kg2hJFj1tj z)`1^OKuQ~HuHmB<5*1o-PZ~zaRI?mHW;UXoVFghF?$?;&zLdFzbL^vq_^4!Jv0^na zorQLtENBcot>BzKG&}uUv;A9Sx1PH6byQEKAVwiEp$}z(t#*3P>&pmh-UhUZiaffA zQaEQqW`Vqz1qV+Jf(0R~lSxxMH%Rx^MSF#eu8th)gYPPNLfs0`- z;NrOMnqcf={SP0`pBnkI-C{`#Sqtcbx;}J4FL5nuR_w!ugB#<`(~7c0q;Y#`$g8(S z)TJoXDD2{&4Qp}7XeO`FR?|iy3K}u5ySjf1nvbx8Wdhl9iDsVr z^Fx{IXes*aszm)70;qui;LKJrD{Ec$CQ6`1(fr@`$>S-f0i6>{YvPVxmNOZl$?~l} zBX?|NU<07=z&3z(6c&0W@Q#`7DQE{=bHtsZEzB!Vf$o}a)R8-=BXY5_C`gU%Ov9^V z?pscHIugh<37jNX(_P&Sf;k|bg}Et4dX&om@sD#`-FXM8w|2EPW!#|8rA3^SS&x|i zFN4dcM5xeWXv0C73r1JX)4pde_CRlYAVm>wEayiaPZSrl+mg~M=7$YsJd8atdKH5Y zAbqi01ZVR?)agx$<(sCMr}WdmclLE4iusJ-Vrc?mwB%E;C`>f|Vi&_Y+V~WV+fSTF zFfRTG!FUtExSA>^uC*G@i`PWnx9t4|qDQ(E6JY-YqNcr}>8W9LzJ;cfJ|)gv`Mqhw z|7ev@ zMw~pPZ+&Ce{ZmrGT#Pl`HuI*IYu*N~a*(;cOTQ79LNZIs+k)+JR#Dez~c1 zmj1Q3b_FzDil$GeWy((9yVZF0@vA=M@#z5AR;5lJ8e0ELF6kx@A6oO)S+Scbm~X4) zgQgM%2d*XGkX3ceOS4 z>)BF`M6l%ie7Afs-!YWFwAVQZ(9)OKk@qJrCLQTAzsBMkl*!7G*==sCUV2&G3g z06{#|@c))a4!nrX=vA^@lXsy`vP5TNU+N{Zw7qL(Rb)_aKVMN-3O4h!wbEu-%>aah z--)9Dh{mxtL0&=VeWZp350TaK!TX|m?gE!&Gf$hXubBpRra|vBq=I>a&Bpez^D>BI zEeLJ!>u2RfBUW*Y;-wEWO8frsnj?cTG@IR{%7AWTXQjQttG|YJk@J6Cq)odhLHj9A zAPa3%-J}Kq32zhbxGyFA6ed?1v{;80d|c|I$vxOJO#0dp$-vw+?3QA}pK#wYL8F09 z+}iriFU-Z-?TqgAU8RkO+=l8-qt6#tPU#IN1~~tb6*}X$5;}yY>-8L_OAR3^r|ZR8 ze<1h{nf1RTxM7j`Zvot;emC}>WkMct-*DpS7Rv{(ZNzy5VaX#k49mg|(e2+(9U4!? z1S4#n>N)k_(~NXozoFxNqO)r`3oFNy)}Zn74rLv(+ESRfvdxTY9FG9gzCWxDCb^Sf z!nr5ufn_8|;>xcXKE#|Q-IC@_H;^qK)J6+4*(2CmkI)X4?Tpzt^Xw z>1lh-XUEAuM|CkuGhhYU!vOEFhxZVwgB@R3K4`eQk}3E#jH<~-lv|JsM&&6c+6n*W zdnSsAvcZ3(YNW0b9cD&X{22E|t|1l_H9GnHS_RBl_UZIDqjn3&eJTBgblq~fwmmx6 zCCPr2^tFK-?wMro5)m!BfTcD-^$+m$Y~5W9x;;l^mAZ3;BUTXtASrHcBhXcs@+(L^Ih`Lq9-*;7=%| z_qw6<20r$*YqIB-% zt#9n_lq!UF%Vs78+HMK!6J0S~*X-Ow|9)_cJ_P<6{kRd4#s^L}SsPD|W&R9no@Fi!f|V^-u|>24BjWBIjSwPuJeF>;SLMf%aD%4eY-1wK!IZt8+I8 zrh@!0q`1m5n{1%TWp?Yoqn9CSrn#BH&7qgE*M;pn{W@ zD~T5_!5x1gKaQ@TJUm>J98p{^g?yOg2yv}Ii|btu%W8mn40^g8CetiKyXqLt(iPTf z)@bX2A?it}Iq)JTLk@v~w)!;xb2&_*t_ zA;g0=Z9|d9!fp7asDRWI&qS${loSrYdh1cP5Dr$fBb?iWmkPo!BQIW+1O4p(k z=whE@?bIPe)6SnajwkN~660=1roEInNz4|03Hibi<%>rj%W~&u-6Gp08qr=I(^&CW zFlh|LgtI+2Q#d1x$(PKxYtmXBE(yAsHy4k#_tW-M zn)I=2Zqe$;l8&J0UJhC{=?Fyk{~~SwzfqFY{%XQ##~i4VOhq8=+$PE=xD>^0BrlN- z#qA5;B1ek|#8u8}hlI2Keo@21MRmO51>Usa_Adj__C>+HXnd$WQ%tBX_VLz?WO1Dj zTn2*GYg8|%0EEaxpY21{FOZYNPr-#^d-H^JE1GmAj}T{m4A8{td(SuY>)zUx-1MP< zv<(wxTD9Eyc3`kHdm-GOr4Q+A_8K=L(Qvzyw1N$qECrnsPFs?xzYqPUJ^{Cr5pJKY z1SiJ=IXOQdZff`tw&t1j%DMA2+AT)exNLGB$StVNr` zPUqE=&-~i2s}k1%Oxf`Y+SMdJ=@G1nrD=Jm&0u-_z8Ca-UjMG`MDOUe_zr9U7E;ae zG~M{|T+2Pnqnj3JaD0Sz7ersaXPk5tAo+HPOA^r2w#G}m!Ssksk1`_OT$Ir_Ln>~( zZ+REQ166zv;^PZ=o5zEJGPEG|m=eK*K$%^gS%?>r^oAns1y(OEO@-S~;5OBAw;IYAs#!-rw{rI24O!zXBxUNv4~yx{ni!j;GH#L-dTEe zr1TWcF1Fsj44DVN_`CRC$~C3vnJY8MiW(wQmyC271tLTecRyv8jJ$*Wi?+nr*m7h_ zfSZE6c_(vNb`bPUcQ% zhEF*>I^;A{{_UM^AKQ{Rvpja@InC17Prp;ZdU;YwcZ&`&_8|t)(cjlCL6m(vjk5bU zRNrRmmqB*R(|aV^E4?O($;Jd_A-@`s*Ry(%QSdodE47x=PHU7zoQps<|AdV&zY5I& zmdN~ejzA$GPb(0Gk64&tlF`jw_KkZs^UM*KLXpCT{T6))LN;+Cv*ntxwMzA?!lZ-Y z2f3MdSxx*=hW$}H(Wi3WvwZO8`P5@Fy#|K-xv{H)`HucZ53?fg9V^;cf6smMOWYGf zIYwqH;^qwP%_B5AnVYmKMgqaoPySa@AE{}-VoG%i)h;@ND|3~SqpDOs3&#_<+Q#r`IB~ZL0Dh4UX|k?R8UX(#3$BU*WR5vDJYHZ zs(#wRA4nqEy$ER+Wl&|Dcy#}je$?kd0Og#np6W~#wWrSI#(wVCMXBK@t@I8!#N-Dm z2+CYE6%^4;OE}KjJ7o+}Zx=63mN;JYOIby}IueJa2ES)5t35{?!Gc;$=}k=t;w6f! z#)UwGtPeEzMXSp-yk_MJtOLIRfsCfCCSXx6F$N!fsBB`=~%acjZ{tcG{oMud&7WNOF zPU3&rKZ$j;h1-E3LE6gHz}x^0?Ih#|gNJHJ%=*)YH^sbRIqua#WI%GVU!m2PxvhLRB0C9c zOJFCZS4TviS%|jPe@A~q163|h7rHlt6^cTj~ch9t&gld`gi?z(kw+7LuLJ9Fc42YuE z&9ZRHEbHJ+mK+EnpMMIW<%Ft8b2dc1#qiIKBMDW&4z6-95&RJkQ^snJYA7D^q1IR( zo|?E6tJ9WT2urC6hf0-(#4;7yF;I!jkuX9Pp$Zs)8)5)LhCISFurvtUe)Qj{F;n5N zbRmty_T_%+hAvFl2rhs0qgju0-BsPF*;A-l5yM!Kg=QnS1IhbG#{KA!+l*n$5m$W^ zRC#J4&!1!o9&0d8+jWUT9}0dvBqL@dCD(BvDrB=jh5F82px1?5*zr5(Z`oayq6P-f zeq`|6?ax{!%0{EH^}B9Lf5tMw&uT~Cr1$Gzfz3EjbdJc6j%hThuAi(-#1zniapp@F z*>T_U{>3_~>0#t(v?z3*gX~}WGyC^7(|I9zS(|$_xbi5^1!^nt*~4l zii4KFWp^{LQ}2aVRJhRAs|E|hiWJa>sL;zGYs;%Z$_@4JW#;rT#Md418#xs1G> zbZ=_3CzyPH5|ZZq<8=!jU;1YtLttP35!wC9jzNeFQQ(M-`9~}Jo7ie`t};OGVipR%hW;QK>?i?Gxs&m{ zv^-)9&%H^C3*t9gUPeMz0?8a55Wf<8g(ll(4j9m+jz9a23-m`&R{f`xy@xopb73(|TUSLjIBBz@Z2$l(s8qmE2szeDKPJE#qS%DAUIoGlmbjMabWo^FEcFK}d(M{BycB zvhY9Q?^BsGS;A3*|Hgt%0{vx-Fixq(eIWwH$S;R0oOyo_=?fg%JXlB@ zCav5Q%!rK6U-%j6cYY>q=)_GsA?LH>nK*zTI=Q@XY$}&EQ6FLtydQ`?t7s`rlT%o` z#&%j+^#=h{Jnw{u2jlhU4QA+VbH|p==*}r;^?rnEXBh2BE zllRU(P(ji@AxV3nrhs@V86At+zgYB}%Hv-=&0`fU9ZP$}A?eU2w6TBPS9}C?c8unK z!PzmNd>ZG1VHJ-d&b5dZD+uiwCZWJ35#?JhbOLr@G!~)tIV=9g?Sg@MEe_P08wb^b+oax*S)c9U0sxR?0-d)6a24$ko) zN3vyDx`md;TCz_fmgu*r1e%)mM2W?U!8x8Ol(S=Tp!5jn zP%1b-woVjf9pcRHE4*u!Z_V{v1XJ9{d)Z6GoP#*LHS6cJx@WbfabA=#_i+}kFx?MX zh1A>gY1Wcl)b_$Wh6;B&qE_qaEKxdUvP3?=q!u$BSD5V(j*XN@XY1iYf7+3bN-SX7 zFGzYU5sokcoC@X0^Y=uFf#Ltbht&y5QmEWD40Q|VYNvx_>zp->p4KLzxe**;m0tTy z>eV-#x_rrVmHKwN2tHC}r_**iX=6{dj zprf#mJBQl*$?0s=0n(baLfmu|9Q;H~&!|k6yd^lB>rfRN*_{DCRmbMQIOFajbs8Fl z(Kh6>M6rf@vZ`;Ui{OQB77GQJYqGlg87;pV&PH-%pb{s!WUmv`RC<}JbZ!gD(@~a? zJBhmTB)%a^MjR_PH2#tyUwXA)ZsM;gH`K(uah&yyxptduOy#f-wvlFI#D^8A}GP7WODb_9&)b zhP-z(odm2*ACIU6wlYt2NqPuvF|Qgj;@WXm!4XGo zrh{p9#1T=XEvazFA}wozDT?XMjTZ%UT1wcgGRU$InR5Krg5Z$pzqY{mpDmdG*@F51 z)WWw1*S~I~XKN56Cz*WoI6KdAJg#B6uSNUnRQcO-?eeMejIG=fmm5r2wL}Mkd-IuN z8Q-X?%dwFLYYyoNCUh~1a!rsg8j!RA4N@YW9-C5WT&o{k**QJjKSqC>-m|WL3y$h{ zLWryCqY8akrT);zX>Y~^kf7j{wyp}ZKCE&cZ4Z*;i!{n+PZO%(6n(>WYaci z7LO$7J>z)z&J~L!=1+0!TLpGhhR&Ay7&hh|5GzxbsJgmNp|W#m);rKoWs8xRxBBo)-6dPq&|72i5Qc}=I+2LE*UYv)vw zKCDW$`rv)kWNJpLHKk~$!SQ8YcLOh5JYpNLs9co_=kD~H!1zpkdM7*fIv-+IgUgi1 zdD4Y1pW?Qb+Xp7|{4;OWALsrJ?E0355MHiV@6r@qDH3s&Gbr4)#@F_xZ@Gk5%=1%M zpSOz-tgP+VsAU|y#8UH$x#lgrRLVP1LSifZh{@IqqMAjX@VY*xdUt7<(TY*h(7qJD zgNy^oi`d!1N`)zL5jzd@jxa3#T+JUiNML}{AdNW-_3Tw!6Zarb%V6OkC0<#QXd>iw zxv*+{Vqz#D&8}#c04#@U#ks?Du`CMqL!I% zcA_$4j3r{OvXjW3qR6B^?^X5l`?8|_>-;~SZV`U+7@PMF_s*2;p*)ez4;xD1u!mSf z+%{<@{-w~Z(hoBiij;Lt>#w>u_NP3W^?|DAg1d2v|L6q8aVV$O( zZLbRyG;BvdA0By;BpkX2qyuxWRzvzrQRk?K+NO;&d|GDwqAS_UHnp0?zcY(p(hk%7 z(K7~~LMR*hlKHrx_s|gy)|F`0JnRa#N)Py5ZPYn_YZpAtZ^iO5eg8a8K^A^F{cOrp zu~^r9mJMc1N{}#I5I3AR^de>8joqGdW z%QW)&MYT?IqkL#R^!N1i$3|bA$zUh8rl%4+I<)f}MYMd;?_WsMsE4`S%H1 z8uzBQxyLWRm{OwYw{ho}o{oTsb7rM!MXEPdueYtqS}zM?%%TL3uaN4{vXEnat^Ftg z0y^UENv_Wy`QSM+fvEtm{`r;V^G!$f`QLl=<=GXi#CD95dwl$P@!8sb=1m)-sq;5Y z*9Dkl+;R)A=79eZuhDDY@Kq2IEa_VoEVSWRNhbZ$vV2LVnwXI87x0D=z5Rwh-id-5 zcb$@Er^a3nnmf+6Uv1J5ubk-dOs1Sh=;FEIyJYT8JCdeb#s;Dt;6gr?Nr1!#`E(O& z1RLaF{u!gCB(_HaQds7+9hwRxQCc=1IXMq3W`O*601Cw>dAi7p_Mh*~mwLF21>c%O z(<<;rVi>~nIZMPO3eP}?p8c_c(sOX~0TQ9?+|8MW{mtKke#n+C&!sanY4+5;`H27t zslX2z`jE)L4|n<{Ich!MX^{17_)WyflyQN6T7p2CfBUL|?Vm?F(JT&Fe9nBCV1aDC zR^?(b6;1i|S4Qvomyu?K+SjBi(+$?>ejH`mXHjAWfBEmsbZ5xO6vHwEx4G#b%ho9q zQd=@S`U18SZIvo33PfdL6SLrR=+6LljuDo*)rMu?sbPc68<~}LWhMJPN4M?#bRDs^ zhgFnJ*btU04_pbD`?gJ;t>NsfddVIGfgXLIyZ%byDc)KBN*qK({~ZPrf~e6Hd-aJr zd-cqMu@XMF+CzeZ36(h1jjbaM-5uQdDgHFn7s60~Oe42$Ho(2FP_8w;b`{)c1#1 zIzKdW!lc#Lp0Bh0EHP3OoZH;TP9>ibZ*_P>|w=@S#fH zK!Ew&p?SBtW$PHqk1a)quZHwLe9Y#F3wb5(&^L+^AhfO7Hi;*5p?{>DwD@+r(knN?z5^*UHT&xQl$F8_cqSDqImV~UfZd}P+iuEq_F6jn$}>?z88vA^?1AUMJ41bugx z&%x5O*e<_FA3S}?-~A`ERu-ZA27_&s(E5&T`6q0osd9C<3`62Kh)~<1x9^V$Wjv57v3ih!FW3PrLp|g{KDhCCUj}kO#i>^&#DM zAPsw0U>wtS=&AUB(BBFE8`T#X_1s;CgJB24=1j=sjcAqrbkTMzk0?9hT$AxkWcta@ z#wCmtdNiYW?>IUk(l4W})u+2CM%Q=YO@~f?ys*|TY|g|dvUtOf|4YR9I>n@jUa^E)@yWfbOJA@h1* zsks2pI9ocU8-v%)k6)%0!-b9N_N`C(wHeEqB5u-hWVX6VxsO}MD&jIR)V+_wz5u(2 zIA`~#mkQc=xTun(tFUMZE@T}kugi)i$OuKq03jNTB`g!#6nd)~n3hFK#(H&=b-j%j z=uDzfdf5L^%CN-z(zV^{^>ZadD)n>Av;?wS*Db0#1(~3zDXn#6k^Fcmt#!azZHHnw z$xINzYZxg^XuiwvsdDW1jN^deA`tF)$z;w?b$?8(!KJ77je~n>jiY`ez61Ma_LRI;1DJ8oNtV|K8TCo;L7_3T- zMA;PAaGXh&?Vh94_N53Uy;YPb7)S~P(7BTg-SoxIz8^X8@Q5!%Smi`lOCP-{?#q?r zSZ4A>x0+~p?Ewa^Fh6ST1WwPx%@G4gO6Kg3Ndctr0AU z#xKx0&6gGA&5)z9Sx6XUr5ccg*L4rRoX*bV{5%u@eEPAJ5TqW;==)%8`W=+IBpF0k zhaK!9FuJPzo$do&P^+)blKhXA`(A%zMAzmvF-9@JQPq{>L_A#!5F6v^+z08dI!=zB zwPH$POooDzpnun-hVb6?lP~;-JPozu%u36P#8;?XLaKeaL|KJ;=x))Eqh_KOUst6X zo_W7p^F{Ba4+C!^N7&X?%pMWMurJ}lQ1R+bwQ}oe(7qbqziuv_CC&P@XAbyy6BaR6 zKcAa~ql&7g-$mEz23GD=`*2Ta7~r)o|83pGw7XoQ>)piuubp_cmw5GUL+##C=EtJ^ zIpI$UHEE9w%llo{zJ9W=^*f0p31^1w*Mm>Hn#P3=Fu5h$Zso=B1h8N^nGIsojFG~I zVZpvNvVUmdtaT)pI#fwhRqB4$>I9E9Sa~|$CT~Eef2@*}Rfzf4D+@xWOW};>bQ;+~ zzNG$|cI@8gD^xDl6Zw-nLB?OKKieEN>+C4@DttK!^fR#_`Omwm{dw2pCa<;QQ1u|f zeRy20J`I?{o;FeWN72|kCuEj&x!S;ON3G!@-ziCW_B8hhkXX^}x-{ugpk`MWfAi(` zm3>KYUOmubyV$k}!#66Aq0=f_l(g1&b)L*MNg;%K!{A$lr#sa;ZJ%Wj9>5oM7UmT% zHzf`)4085*80`r8Pi0bBsl8-<#J03uhSr*trLJ;_)5_Tu^_&$g-eqST-v^xYyaREi z_PW*U(68n{Y#7-XO1pgXQU%)ONpj8IO>rND)$AIY4U8E>Txzm>nmm^)Cr}UZ6Y)+U z^t`+iH%aa7F5UZYGqvH*naWysUH_Ep(tGRUCO*<4s$EPV=E%+!PPfP3J<`lK2-}oq z)A%ww>c(FpS?jMNa+;*f*ZD#|I<(YBCpxkIZK?n1ZA85^4|`>#xJqp9eu~iVTQ>gS zkzqbwG0b)ZNw5B;0y*n#iH9&t2N9XjN8mPR78@zrOqgsh$>a+KY&A^jeac;TCjGBN z{&biFa><`=9b~tkxaoQ<37n1};N`C=a$TGnElHNj-z%xbg(0iIJ~dkA`V#vp7V zzSS%aNS_Iv20H<9`Ee%L(o(hHEFdHvbi%#C=>is?kU`cK}Vbp2N+H>XDE(HYdqG7#$sF1uRS19n`?5UwhV&@%v4@ZCUzCq^a=%F>Sj6S$HZ%Ypz@JiOK& z1JLy1BjqPpkHw6f>0OGU^;Qh66EL(+prJK4FV?D^nF;?6N^6n=!ovS@v%dfP&8FdI z$H`lo*&xU(G$YsrEKV3J!jbF75u@N>RCmbID!&=8d$fzjSSB%^|V?@lv z<{H1_y!kN+Pht{IPf(J(J(CIW+9c%?%X1yuRzEPfl;x6)K2~N@@~-2a?~bb)`{ec` zSKzjf#;;H6SFR2pDSWzf*Oyg7!x|WX2Gn#!>edi++cf?C3KGn7n*#EwrNfem?S^4?i20H1WrzOo0pl;!FjnbY z7Lubwh&t4kL{8^qwY!L*j9RX_x4Y1tdJ1XS!Xnie2W@2b>UH`DKdo~=VI}O9_BQxzt)1FSCkOW752EaS zfGyD+?88JbB$F^+!B!&X*?Sp1*9nO9;p^cf4-ns}@F*nP6F#(nd`kAuDc1RB?wq{{ zy+=0#ggLi$$G&wvK11^Yin|UzS>9s(*77>1pGRL39KM84OBvtL#D}bf)lMyV96^## z*ndegWv}fnCvh2dmchtdgeN;kY@w)BKhW)%e3M~M^Zv8K9=pL>2>9?}n@ZieZm+IO zw!P0R9~^2EWfxjfIxKt}ik;KX(p(aWA4k%MtNNRShDs&5a-c4 zMP7KG<~)0iXs*=MOYg2mA=S8}@aWqH<_*V7n5|(r2JU4Wf~6Dohil?ZHV*T`H@?_%eIj$uM7V$NBuSBhrS>a)gV~dQb>Rf zk-;G`JEO97lG{leuQMO3VkZwHd-^YS2POcq)u*vk$<#2x7PZ7u`X#u|dod7Wdc&f} z!>rZ)lfb8BvFk-KTHdGyE6@Ng5t*WM1p=mMjG2G=)RuO-S0o*RkO&=x8HJ=P$(Lku znl7x>CYY*)`Aef?B$F7@njeNfQCfn;3AVr?)(B2y3+TNU0M{?#xulG(`wCwYF@sOkqHPr*=lk7;FF*-; z-92y_)A4N{#bS1v^5+llUHbP!87h+1`)%4|y#PFmk*+R#%r;TU@^Lgx5vgJUrGnf< z`JAwqS8WGxoPK{oh^OkK5oVI+@JjMPpXF{7Z4JUTw(WodLZDvxmw3JF5mVYebp94f zT_E}8kUB3b>TCS4r!jIn<(c0NwrxWVX4`UCebmBw^fn-$e}Xyb3`QI6gp}+oYcA!3rRI^R7v-Qu z+xjyvYzIm*_?n1=>7d{TSAl}>{TdV)cAF<`e^x9|vMc+fSo& z%w~NJW_3vyD!+U_kV>)KMWo>;6)2&!_Ct0R+^i6FmKS0GPU8^09S1BUj^(L zPOd=`%LQG}HcfqVZy;TLe#FJCRBMT|yD$dL{@$%#f#;Y2nwK(C7%-i6h@MCXa_L9? zO#s|lx+HfOrqf+my{%y&o0DIlrSXwH7eYgArFJ)dS2vAp11|{T^0C%;YvUbsX{+>V zkFQf^Y_4n4p>(15sd5Y<^4hhHw=LZ4#;Pn%Z-*H!(N%J?jecK#ZOP*U$K8^1cioTo z^iUwI`c~x<?(g@Zu}}p;9K|TqNV$Z0H3o5?->tMOkjI*_!0zL@xaXYbCKtDBO%6U} zAa{1At$TCDmi3kucvfu%=68uVl70~H!>PuO5ZHeceON$KNd!k5y!L}wLA7b*j!=+n zRnHIH!kLu7Sb_Y23+j<|%7fQzw{nTrAX)Ceb!6uZSfm$lCc{VrD=SE;Q_4LSW&B&= zK)?QW+h_ClZuT^`+H9lV(?;t3>@)nb*-|0Bt02=GmuX$aWcr;u(w{-5uVjk2jmdQ7 zT=lIW(-l_}WiXlkRtJ;mVo0V7gG|>T-NIzLfSSk7?x4g2w`vZniEe|8*m1AMR4sTppB>ZQfX z+uwii#>P)uz;!tUwG$Eeh*vKC7kY8$Ydt&XAhciLOr|iSxQSj|K=<3<^YF9pIFos7 zX1*AX42Id(a*Ix3eunM5^Z4M!pWpiz4$Qj}>8L-AcA%fv`g!t;R3psN=HP`$(#_kD z*=M0;8~NzOwNA_g)uPo!@)znN+i7)?k|N3}-2yiZGjCdNAv=4g15%dA4PI_YIHf;~ zpYlJ#HxR}RAZkk^e-6&-Rs`;A8u{(UO!*(xB*SZiF#>r=+DHsTpy1FIIvS7t@W zRFnNXUQMvC7ZVaj$T_aZxlC{~O!Igsck$FFI2YUn$Vsd5XX#+bc@~hG}(r3-X^2)47zuA8J==FC9 z=OfP`*aNy{`(AU{rK4G#BgPY$-K?PhA8kaHA4LLS^>b#0e3$TwY|VRSzf}XIyBm`3 zb#amTq6)Uk(Ke&Bekt<;BIu^D9HSJ)`nXg88?Jfindc@5_7kP{^mE3cy*`|=k`2v8 zsSy5R4e^bE{&SSXgw(gYr#&Q6vONv4jucUpTVHPqgxhk=2`je$U=(^&{&Ba~^cHvO7Du3A|6Wr3*>dQhzPlrT_6&qf2JvPfof)XZdmICbu;r zH4{CJg|Zk8RC+jEIwaf;Pi{;<^HD1Q9DZCq;rJSnp@|-ie(i}%w+Kl)N4BFCXgj;S zkfZOE4`(P7y7p|b#)|y)Z|gEfcdvPy;}*VeAJz7wMztiu;n6-~U@LuW!@NwE^euSq zPkk2@%lzlsPR`v;A2W4*>GDVb@~>Qd&I4{I{!bMaeZemWlg%=2@KdBirHec7sV1yK z(4Q51y!HO-Ea~F0@UOYX@aSOc_ckvDX{I`k0U_J+T|n6059_U(rixj!ez0J_`Esx{ z{%9LA*dh{`*z|K=->UMD`5>kV!Pmpo~m?{0{j$f%z|7uFQE?HNJ#{FJC7QbRfp60C#pMA)s8mmZt$s=i=2blH5G-(5bDC_km*9n_i}y3+u? z%)-6Aqc`M}lg7~ghK{+8??QTtC-2OcPBGk*m>Vyqv!x!nAvfz+CqO~~m|`DyQe;cn zSeXoL-fkPK0Dr4U4XpB$^ZfP@-kXz8y21NPj<5L|aDLr)d4EhATG#a9VXs?bNvOxl zl-bX1Rd9*4$J@ z+s>D@hxMl&$$d6KZK)Go{oJi$SuV4nlLsmLM=Q4U2A$~TH#`0^BaS)Z6_%2B`JR~z zEX@0h%93v))U1g9=%1t+Y`knx*w3 zDl(NV+S;(p)2%d+&3RT3QN|7Hyi45P(tRxVTy&o~KRSPb1pf1QN*PCq_UL?Kv7ss* z5St(6_=LW>V0rvtqU}~r(fe4U=bpw*JZ;td=c+RQ={N)HVu{) z=5>>!{jp|bB%Y&c(T~#4)3>vA!!RCsF45;0$t(<=A6PPHVdb~_G1x0~CKpgU4PE2h zJ?*S&r#Vcbfal>)hl}5$5Wm6t4c6qoJ<>y|YPI2}eo{r_PtWU;zDPN&Dyj(VaC&6J z-T=a>@D-Ii2~g40?ASqI6j~oDO)KgsOQ;*K>uEeqhgyX?NTx(SrTzqc;!)cSiOmRh zMhh$%D^3J%2272VL6~YALt5dT(P)8v)3TJy13~C{3_=S-5rm>QY-w241lx*0d>fXy_p4Rjh0@6ULUTR#)2qKKyY~m5nm_h(3iGqb_vSMeYw*gA-vK|F&;11-<`>r5fPI*M z#IUTGB2Wk+uBb`u#>#Xtt+&P}YBSz4N4&%03}5N&7Sz#dbBuaVA5G&$jcMm6Uvxh- zKE;_#Vr#Hr*15j7nA(_wGZ{xeP_8kE4K!@E383D?0DNK(R^tsrd#CIYC%ThI3e|i+l*0d$XNT5L`4b>?#JvOMmD6Vp3dX{rPM$VT z`B(siTYu>0fcjTBQE)ezCgzPXF<%^!Iu^LU)pwi?2rNfCt-exyUsu z+-iTQ#lTBZdraHkOGI3L^RoQ=;O4Y;V|(sH;RHx&Jitx+`6Py(c|Cn?W`%hrl-DXR zzi5`$ethx7uSBNTg^#7Ps{_v6^2eWlzgzc3 zFL&qmS7Y1NT5O+{60X7*b@n%}v&(|HM#08L*=AkOR%*)dN%D$W+d6JMWLoZ$WfZY; zx%(zI8EJVD&zc^5kuLN726M(zw(^*{>|k7z%8ilmyY=am)~85099VtaLupFi#b;G! z-iJowz*FVMdRtG}H4|hjm$cx%Y`26al@K^pVBjvL%-PCHtZnsWiU40xL|Pd4E@MQP z0LPTzNDu=H*VG*!PNA~nu0h9nG1WgCO*ap`jqAC33jgz0<++1>-D4!mv!JJS@Ve@ zycx^3)3sDG2Tv?7VUFz*vPeJqx#M7&FAM6#!8?N1%7rX$$yT;j0aaEFP}80uYvx`0 z+zl<>u}m3$<2%-Di_X<4X9&2}%UUa!u;3|I6Zb#N$UnLT*-g$~8#gPRFR{m0%G9f; z6g?0(=0w%h=OTG4G)b*$`S`HMncrQrQhdE85 z+gfr2Uul!#{4gW$s5ZJXt5J3S$nsd<_iw*jBMd8v+BetLe*t|@!!%=F9>%N%j;Oak z_&_MN$i^@V@wBWaWEf0lG;(8nG_By1L`T=w(yvEnO`jssv65}o>87Kz8__rTeH$Di z&?lp@Pd4&&^J$<*qBb0am*8yt?Ik$T|JzG&yxphTMue5}Cc^KE8I9SgfVD8uHRV5Z zpey5J>Tcr6w;-E{C-&}19enG7#ly`^)k`H-_)5zc>M8Fs#ckQKqO@>*qk>w}(^aYR zq83o)Nmn`HqL@EExNS5%@9W;LKyTsf<@Zn0%4^H5@s-^#)l+mHh)ZKD;InK=LxJ8g$XxUi1x3f+JuDE_4f79NQCVe-<6Pa7gh21wlF%{ThJDjV-yTP7b${D@^;G@z$K&(-fM+GjN_Lm4rmFm? zjV`WG98lzT75wb?QRCcdOpD1&YIk@xl!SURbTrS28>lodk=S^o$Z@_`VqNB}OP=_d zuRezLbL8Y8f{05A#h)6?+Sod5QIzKK+^of1+E%^65nU9i64_54N=lUrlsvRmyTX6FjJY zQ_eDS3Kuf*>}=ZQmxWcw9;P+RU(kTxogK_LJU(4i0ovV$eTiN98UBil$E$Amwkp9n z!TvQ3>^Qm1oiYW>^S|gG6@#}FIT<+_g}&#gW_#<{LZ;f^Wv$~m+U3a^HB`z}V^GN) z;$m&6okKb;SdsAzwXz1aa*wA;EKx#g3sK(ft=Ai!FO5-k=jzUJ~BSst%QgeLM3dJIG-urQqbsmLAs--5R%$CXHt>DQllkvlBm8eH|$Z z6`X80_T4bnY^dUGVQ0hrF6r1K@slDYnNs{^`L|n~M;sn4uOHZV(Jm)cxFX{XjG99k zM$MRh@|Hz6Gt*i&x91t(BWz6CL}P_wgkn0^8J~d0)~R?m9bw2l^WEFtSjPYOmYjy1 z3aVM-PIIfB_beaSE6T`L4P1t|n`$n+i#5gJ$Gcdsl=a1%r3rH}pZ$D#*zXLylPSQM zK^nc9lz#=I9`;@|wKMP#HN2I{0KF|tnt=#(3?1`4bB6!g zTRqeJKHvBKKHuwiUH|L4Yg=pWd+mMpuCIPVv_84dvLv)Ovt> zpagDcQvQft>uFgTXK+JD57d+;4OlLL8)`b7cz>5pdD=3CaUJqeDs_LTUMe#s0Tp*X zQYgM6>G?3bf?M)=w@ypm1Bw+|2puYGo;_W&5oCPNcMV=N0IeQU z;=OW-U>RgstOw438%uplIJ>q?3aO;$nR+i>llr^yfZNYVr689d9f;vw zp^l`3>`I(6yB}SSa?rPOI7(^hwQryCKAR5nH9iOjzr?eKe8#M{$(=-&7mCQclbnDe z@+yueASm!RDm@Y}n$q7xm4s5pZ}B7$vWZW22C`7M?lF9eCr_o-Y9M>R3}p|#C%Zuk zKmj!V=A^(qNP&2~uV3@ERN1q`aLS(X(tsCfsmwkQnIS^J%@qO!+-zQj6vH@m2)G$X z1p_x38DYiCg!UrkrN*QrdI$>i0c7#8K;7+HBq~sBn|Uuta|;gAP~G!0+gNq9wO3>e z0^xSLhVPtkaC@MVw45!KQcjI93N0lgDug%=vKZ3tBR>=GjGvPzfZ6g@92NF{^F2RW z$^HamTP8S_?c~-Ro@9vbQtbu~PDxVSOGzpfhEkHYX71fM?RN${ahqgG@f|(o_`S#A z!t=V@@1q9z)!C4}lq6O-B?9AIZ3;3<&-~5VBSCOd?D|JTS>U!}_vT^XZC+Kedk@kpe!|$q21u?$SMukJL-m&A zx-!L2II+@KR#1w}IUHbUHB6SJ;bcB@hlBM?${vRZHJRv^uK#Tn?@|dv&pQmTu%@?@??$&TOvH~mY zxQzVMi|jM*@U0a6TaM^oAtl~E>xjQDY6{A?&HlU^RP!=v?3?*pfZ%!!0JgmOBSP?$ z$pJPG4L{-EJ-TzxzJ1bqP*Yw)cn>Xez!$U=g#(vjg-o3QyME9@eghyG;5U%t@xdtzEJtYz$6vbW&Z*SnhV z$se!i{F{HfkRQjty7LE@lUS3Y4HEtPd{o#CaK8rM>%tBzOWTe4H(m~%gpAN=V`p2z z2N@Hv%+&MLUEQ=;nDUq(GSc}r1&7(sE2_6S#2Gi!aLetT$s7*++@$wUV6435EOz(} zG0t@rnZNO?6>!IsM6$qszt2tQBZzk_B7Qnlkukjdji1E1<-lX;wL(@jUQu4c{r(9Q zh50bj8^LEPRNwmYpe54OozoIYoAmXned6!#zW4~lr;FT-Ag2EF^>)XSz9u1*mymye zvR{Y%`7V&o34+&O^Jf;qS0#{Kgmu3RB^S-S*M*ad;s%K0w}h1jAr-~zn-#30#BcE9 zeSddHGq&u^KDm|27r6#KdYQ!Yo2Y>)fO-GT^BBL4DC$E0FILWK;#V$GmXu~9l+5V? zCv$%HfRZ_zGoWP7W->ULGk7mJEs7T;%Q4s1ri38xH$ZqBhP+P-`5lImIUnt%^@zi1 zJ!Eq4#dbZ)rOHx*Ki+*8PBDHj99qP-<`#&S_M|R#`FE%y=ipmWL9!L^MPl;16Mk|m zY6Co@gJkNvd#~#v-+XZ&SUVZH=b?M-eV>S!B-nz=%rc9O6{RSkr2-uL2Dn!>d}bzu zW?$m}eeIk#A^H08_oS^pC+B2~=-PqyC6O@ql=G7Gp&-dHWdv)(Zj@-&X`Ep}de zYG5+F*p(xGEOv>9Ks_Qh3##8h?c~caZ&6 zh+B%4z*!c(T$-@#i&zi{n3oKwRvglNIAHsb2E)Y|oyHKI4O!UmYC0ap&LZax!QPkX zl4{lAcjlkynI8>G$&=J}yE@^>pwtS3Ze{93K0J&jti(5;I zZBHscm*+tVl|H(_{79K>PLj*J^&yVJLYA%t#NdJ{uvadBQY!j=ts44EDhA>)#kYOG zTsi`$IU6t4D;6i6fpV`JWh`wN80bFON8**awLI9%>R1C+u^ z$t_3*rEoqR{PiK6!a3?14NAY)ERD5E-m`_^D8%}KyN4!vK`1V!L^kq<%pN9cz2xLX zFTk_EH3oQgd2&$EBwr&R8p3fDei1rt3ox!tMx5tgCqS1F;ClCGYnW=8ngG}l{fBRd zR%|d@CiP)Q+?gqoICLQ-r0Kagp)4MJJ^!^fZl|N{HP_E}Dd6bhZ+>;t7oF*zy9ogn;khYn`ukyx&LgpPha}o$X@30D-s1MUuaIZj*!ZzylTM+~y49 zUK<4B->rX^9g0Rl*v2^br&OV|r&;q<;yP5eQqEj!+#&DDVs|AuxCHzi&%SvzD+5DR zA2&s9U-)6SUB(@ofNVG4+5AT1L_>{ZFW!0XS}+Na7Erz9dZ2(ifxM(Wy?hGMg#;I22L!mldhW7!5n2ed2@w*zAmaIZ9;xLD z5kNej6VZ3Me`IKGt1ur3_~PBMqd*6u_;QGiGe19m0Tp-t0f27{IIqaKA#VTO+aPbU zvW5@1ED51JQ;L1W(xFt|Oy=mJ5B z>2Gfo_-}Iz0CV2tBDjmc0c%ayNb8_nT9>_C+UdPq+PGj1kR@+1nMn#M^Hk&ap2Kp` z+f4a}u`3C!_t)YI|Yf@@I4VLwDj#5V_WyAUpYPp5 z6+iA9ugp!g_d{Be<0;W#SWAktBe@CLmk0Ok%X@qF6-`3JtFNKVQ$N@QP=ziCNg$7RdRvO`ep!}5Gr}ipx zfa?*z_n2~!*HMB}A*W=7>7YBK%o#^U0R?rM)%-wEzbxhP-jk=Y_vCrJzrd@^OY(bC zA-ER674dIwVV~x{TV$X1**s5-fo|>p487cXpm0Ng@i3#`@A;JN8j~IY~Ms zSAN-(D|;^$qX2LZZAd_m+;7eg6k6C1Pa<{kGY#oCFDP$S555+&^8Om6GtZyK?1OII zq3~v1SOQUSfHF1!HG6&!HJboG_74R71m61!L86K?yjca_an+6DHDBsO4Y?zG53<&; z(1YylqjO3`nWyNU9<*Snfs!k~!VAW?eUBjj#>+kbhW-!#2Ki(1{`PaDrQquTPI4EZ z9TnpJh@VfZ3n*k^X|xHWOov0gLpf)6yhxno8vW z$uh|(quVE02xM{!fJ|<_n%1U+9}Y3HK*W&Xc&Kr^Jh+YzA2`V=z!zMAc#(j2oNWRK zWbh=#Fhe^dPHh(2h_(&!f#*mUtVsJI-}SZzcYn6S7r(tb z_IL1a@9Mesxsijvr7mx+@Q{qoijiJ;9ziT?^7`%^;pkx{%s~;dmQ;uL*@TcTy0SP`vdLn8zYF(UwBUK zM@>?LfR-ir4No!SxhmwMcJ2#|O_Y#0#$<`*#dhai}L=*!7m#QR(Z0zSs9t zLAM8ZQ(~YhE-{+$5-G$5?d^NRei7X9li-e5_+F2s+`EqhAZp&p`$Bzs^ccW9jl@`r z5T3;2eSWW7z_HHz4j|Qj15B;IRV><-pZpChgev@6*0@j|v>Ww{o_(uV{c0L7jI_@O zAOyuF*Gppe2$&%rmBM7>b_Q_hLtfXV6<|5yADIH4o|MBtj-+~H7NOHYoI(KKlOjkI zzc)SWGywOZ3X|O$31+=*#F9bHG~naiS6doqrUH|GCDeHv$0E{QF- zy9V{gQ5;lMiyFP}nY2`827CrozBhcYA1v!718ZCjcO0G;I=6wr<=W=rayhB-xpq3n zaZtw2dH(ZVXWQ)u{6ugz{)J=9RPkZv`>LF5nf;*>Yyg0#MZyb&U+-bqj}3~}$thDD zvTMzkqK>2jH6_<;U&hiO4nAUk~zqoxHd?4W>-GRqAFE95Hw?aa2lNKz0!d^bKOQIu-|n`m|) zum&0uHiTeT_l_tict8#c9#{gfn`p-Sa&8`IwKctj%mT$8*1G|m4AR-C!Lu60_k6og zlGPH+2-K>>!1)CGq}oR)-ft5RNsqz>5VWTD3LwzH1rYi+Ns4CCk%n?2kP?&ulpsNP za!1m0ke+^dPfy=d2>CATyRdK068xM$m}M8=BWsFTe`aHFH5SG%A!}q=y@yq_U+66s ziZ)Qq!6n@5gORRbqipKiRV8~ULMA+9#Ao_+WQH$P%*E@ zIjKgtm{%udQ#Vx1>j@8^=BQJx?gV&W)o%icc1a2G0$x>4@F+a94CI^tWlVAfSf5?5 z|1WmS*5^{cvXhpOXQSp$Rb+5&9~L-=ZUSG6uVpK64n48qT>5EEYhj*vHJ6t`&Y@w* zIb?df1vqbRt#Tx`0!0JhAP>+&rm>;XC;Or|k;7(l(gFXmPTcxwao{}vmojW-7>(v> z32;*P!&jS|WRXy}Uz=VuuL_Pj<(cX}**B`&ma3s@3pxCN;qqsc~&+6$`R6;!8K z1gX@^XPVZaJK%vlG#~}32gEVlErz#yZXn(Zr;=bdkmLOzx&hZ0pd4~9a0D>|N6=f_ z=pRm|+4mts37}ZR+h-4%TlUgNy>sepqYYyW`@lz+&VuBNmW0hK2Fo9hnO>q8i2=z? zGJO!@NI{d;<805hMy?F^vj_f|=lSn#ySRwIGe?0tiStrzi?im!e;%fveE5F z@2nV{YXMlm<2XnWc}As5{|@9o9|O)g)RrF~-}3l$Ja8!a{&Xmf>^YRS2O)=2;%ijG zTzkG-(}$DWi6*y&H#TYT+{5oH)*%Cd=GTh_~8jo9}Iog=uLP=Y8};RgWw zvS2-mJ9Q%s^cD z&VKrT?3ez3YYZTd>~pWQp#oR+Ls_`No2At_Y+$b&O7CU&@B+Ip;q#y_LjVu_-0<+# z)XV(aDk`xUhAp^`ipVf}dxZvI;8x`=(JZ1xXsCz+K?tn;vF&{+@D-_XSg=|A)&XH`X|9nYRLVG=H2C18;`o&B~jyKI0 z0pG46T?TpY4|n>etoj1#J7K`<L;En{XCkb1Q zpcS34waxaWT~KPdStJvsWizIe{oGgK<+Myk(yg8COd-Nbm<9sXT{kZBdGT0J-BL-Z#`DznUd+rm;}O=1pP#)J9uw{#*M!~>DY|TzkG^p zyv(|&eHS_k1~s_0s-fjA3-fGkcV|KS#O<*lk}JSqGH)5MiBvg}hs**FfjVh@2M%se zicvW9?zqjmZqsFbs2Z&e#veGh5s>4_b|or(CO^mXcrGR+*DZafI>%EiSLsnMWBQDx z?s`$q&iTvuqqzhDh*H*!U5a!~7;|S;TorQ*)O*&ix>jE?S-jjQ-?MJ&T5Vv$ce#(M zXT4}<$Ium@Ug4{2g48oXCb%e0mrYq@RPbKz3z+e|Y!a0_n?K{3SAlt1;FddEJ>ywe zp_EeqrnQ85&qKU~%nE|!wC5Lx&Q>*7#hd~#ZB7O6l|Ezmp!(23y`Y2oT!IeT4)cc1 z>;PU3SG@I?^@4a8lbNxBvlzv(frnve9nxQj8C=E~-}d4}8SnDauN~f!NXAyg(H(-L zsG9m^Bwr8W=+N@j0j%6{1Pw9G}wUwd~`s~A~{@q%`s_?cc5V%&?)9| zDvobjetXn{Z@O}gtPSzSZ8|s!nYs9d@eJ|8$P2#vgeNtch$S4qPn_@6w)&1J{@ZHQ zn#s=SBp-T$)YKR3se=G}Hi>y|KzrihJ$K+e*Wf*;C!wjk+M%hlQP9+YVM~y4X9b$` z_dSypB#WS#|Ly+ZR8YR~so-(raguc_y!RZj#?^Gp+U~)ZTSY<(8ys zbvo~yDJPZ|EK?O;vnGDn95)@lyw0Ij>roq=w;Pf4BxyOj@4$Cb0f#z{@vue(UBeCP zBK3+u(e2loRxAmDLWbv09HY@vjkz9omNJXKm}-7GrIXf*8uWM%39L~osz%vqt93AY z2J(71h<+TT#;YL17k5suoCI^c%i5b`ASE(YK$1pl1;abfpT{pr&2YNLvLsWZgLyDe zdb?a}iUsWKVOhy;q#D;DxY(v~)S2Z_Af?BM-FcTl=`^hZYgVvBnkFVbCRNad#$;uo z<|I~NZ<^A5XH*kAg!)QoOkifaVO32q-$b$;jRebJzy{|?kr8~l*E@flZrkst`|kcu z0D*I4-7rZlQ*$cXwjxj{O~WdBewzAM)tC-}#TNBJ^TxnH$}|;BkI24+NY>as)l)Y9Cd+5T2(rjz`g@X0Sb0HstH%zB=Z)mt`2v; zs>m>ORWF)}wCLe!&6Q7Zbz@7&X!6QvGR|m{&uHSxXxdG0`kLNUnckF`-sF|u!J>s> z*1|ApVHmYA`?W9(S{QmQ44oE+RtrNDq-M3EWVIq~wIXV@B4o9~Yqi2|wX)x8h0_WDaCbmc)2c>w@bhg@gOl$# znwXe-iPE0esJ+b!oK)p zEdqpH`AjZnoeUi66%Pmsev|)LxS&j!?s{I1k3#t9;IEqy{H;ZGwj5m@f;fVYpu}Wr z%ISb;pARc~+|DsnT}}%c_^=GnP^c=WfrLJXFxYKtW$ft0Dg{E2csN}RciUM zT|jT0`CED;R)-jqjs*9(SN^?qySG`3g_H!sz_{~UDkE03fGzkl`!-#1)`;J=efc55 zx2cMScw-I#hD1BR-nz=$q{TuQ;qAVJt;d;Wwquh5yAW3sXzNFNl*X?h%(bKwB=wc_y*?JyDCX4O!ZOeTe@uM1N9E)m*sVF+H7c!`o;6h zRJu47HsXm;Bzryj(U{q}WfV*?rD0jpx!WpIh#ahX4=yKRBo|wjyPa&~o1HL{huzHG z4zMAlCLpi2BJ!|imsiDdw{-x;U>hyIc)vso-Q{Ry%-zR}e3Ww!PPiSix{@A09e7^tn&j)Hsm*Ie3GWY*@g0l&1bGUC0!) zLRA$Bi%U_{g|<0jk6tstJu$*5cG;vX4Tit|{OOl*tGAyyBNv+#uw@@`H9kXS+pV{^ zw+J~GojbT|5(6-)GE)&PEg4*El-0U}!%PJOm`kNTnd3yhI(v}f&0>~Rg& zh$vYzTvf&H1zrtaB-XoD-1kn=IH(%tJzk!wvurDW`qk5o-kAo6l&fo@&TdQJwdu#0 z{AB}=?LQKF)~fzU@fgz?C+cL`KvQm2vHdrhf=@j=5v{0^jxQ^-U(2_e@G>Kdj(TE;oIr$fC<(* z^glXm(9@=^_!muw4$Fd^cyjb>-_dm=_;^MS%ccM!Fpu*Qcc3gOLih+kPh zbvQ@KcBS@wD#9qETyVOOC3R5) z+u^N;)SZX5u?JJKTb2~=Jd6`L zU3D>Jw2O^X$=bBv3L;KPG5Q1!wN|!cR)k)xxh6yl(BLL%s>kSKYj3x?k*=+>$pxP%FHpqVAY7v4337K+Epe8(KHJeX2p-6! z`>TF^gM^4-_H%s!Q=V)lQR%b!Q=Z2wFd+qQ>9hDuh-zV))aYxEDKHZpbY9_D;fz{!l=JY$~TDWyCT8Hx?hpZZcM4>yC}=;&BsGa7Mq>@!m4(b1D;Y zOC;0{XEA+Itr@jD_ZJX(^?|CmyJ}Z1yaIMBD;TGr!0Ud&%BNB8R8uRC4FDG{IYY@jJ|!t7-A zYwwcckD!AFbnt@?AE@I41;+_HYk$B>1z6bu>zNzdHr9TigZQ-Y*@i)lQH2@k@Ey_A zf4{b5njIX(t|EAeM(39Y7Y?&Lsw?qgOF>+BqRq>q{#P>8XY&LaK~Ur| z$#ZFZwDXsy9;!;Pc^+{HdhDi}#;l5=I^q!U*iGeA;^7HJrWJN-530Z_QdI(ugO~Ui zfj@%WI!l-f#&t4o$MCICAtu^=KJo3IvNz6Xv}AwEL{5G)L+TR6nof$TJGf`3-3$o^v#S}OWgU2Nz?M3B|^U0SHZB7OOq_%T7QUX7vrzCB}% z(O}c~ae%gpUfnT~Td{0!p28Hv_6ATKL{5((T0S8%W~f&emidT7gBc}o-aDF2Tv9*$ z*m_?q$7iBv2e-IQB&U?R9ZYkQ>JUjm#4QPtf^DRGFZXh~+}L^NI^kAkR2H|mw0m~s8dMf&STnD75>kYL%iUxl*smtBI;YD^=#WW%qONPYbw5$(P_u>U-xL*78LY^} z?kaP1P()UcoJ^&g^7o)qaFp6p?O#wWd`~@Z^@Py~((I=m=X+2df~9GrbenE-7ExX0rk!S{fnN8;dtKdJwU|9@8h&1d3!94h<^ zj?K||Sl|h{6=B!KmaAghacH|h9!A)lpvn9d*hH>L!e z1q%^B%w3B*UfK#(v~~+L^YK?A?+cIO8?IG9*|%N@+$@h6&8Eth#?Aq4zLA6DC`zo{ z$LTQe=T&lS0zJPR>BI{f!5n>%(vKUH1-qG<4n6d)`IbE)krhqoOSml#^!Mm$pub=2 zRkatgf^&_>M#_SOa87AzL>)s_ZBakq~Y3lU=H0(#fDnEr{yfIRSq+=!L2 zX}^`0g3xhbM@SElR)^%J)s~H&fv+|;k45-s_y0M7Rm9lhP{xPKR=aG<=&2(J# zG2-FRh({}^^V{v|I1XJx*fC-ZM944hoxN%$h@1_o9zxC_-<4hC9>UcUwEq0!#$L;7IOLjaL{OdiDBD)69g}cu$kEYKTdLXw;&b*aJgB zVC7%$`C;V?$67(wepTY7d)Gdm6fN+I)+1OA zs}Whz+{?JZ>z|FB9P;f63)bp|S6=?Fy>nrOs5h z@Y)Qk=Q>TmPN0gnwK&}%NuC@>N=V&@eBWkOI{jM9(%Y@s^0o}u zAFujixEk!m8BXp56-Yufnjkxhzx>;&iKeZP&aN|Jud3|{#vNH0CwnK~*O~#hlT=Q( z9Xn_l8(#DjrkL;|KyeT`KR?}e^RsNbeuGEK>9%GzC)2FJRcl&Vl;nsVO!Ns3l&vxu z*hJmc)~hgSueJg*g-K<#6;Kg2aZ+UD;=AmL!nhw>odgGIm;iGC%$&1rkq1-uwgsR< zh_I96!P|JVw*%5cF1n86VMbGLU<4@_O&MS%Jsa_;bUKIR^>(7(v+ z2rYRB#{C~Qb-ih{YcWFG<|h(`icge_xrgz{OFu$WkBOykg&iZLA3%17qNnQ2T*kz9 zn#|T>(40a@@r#5ph3&A_2{F+abUA2Pzva-G5k2I}5m6DAx^Oh7^3jZFdPUgP;q!S5 z>H2P+FDs{dOx9*ZDP1`ND#D6j3abcfo)C?0X4+iMTu9e->&&U7o)Pu02+LVGnp
r`i|ZS@n0PFU8Vcsd7(!BMlVaP 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

    y|uJW#w;9=xq`X!e%Eh!m~98F z!3umP7UU~-_!c=SVN-U z5X>s(^%TZqC`LSQ%~Kld8I&^F_Zof8&lQxpzp@toZbYx9<3{i5vbxdwOyqcy#!VWV z8I(rZJN%4fXp6sygFoX9Au>x#G&#}WRIB3OKvObGNW|)g7~AVd&LE6DrRka)mIK!v zIRm0o4+dQpD_EJ52R=$S|H^xsV*Tj*NBYyG&-0)2=gohJWOSwpn{)F2>;~2!Fo>_P zranVEXms_0dzt{dk*C72K4)vDFA(oF>zpY+XaKJS%{t>xxQN!K!Gyd=*V)%eK$igf zOxGpU!z+vON6$wsreP4C ze7#?Fub9~XXDv-%2y`$t^Z4KO#L0W0o|vl|sMIOv86A}J=f{iYl?oTfdcsC357Pp! zhLDl&G%W(t(re*~k|`E@$M2fW+nPmo0aM;H^?IIwR@u8zX~|>pUB+G8yzRY1;Oh70 zc3!tML;i6YLVi7aRda6g$)hp$|L1@k99lP*%`3sklGg?6{US;y5HixE?Jk5?4lfMSoT2tHia@$}j3?s{d}6PBk+;OJSBi{_bI7yc3J4mNt#u#zBSnt z${2vEd_DzGmCUcrpD6OD*+)D^@gA;?lA7+I30}Tkg>TRyfM>#ub(QB;X2g1d;KiOU zczJoNdN_S z6tk$wjK?^MC=SMB2EOp7XEeDf+ztk$&cOOUx!uDoeqI4&{Fn@=sQ&jjrTAoJyjT0< zu&n!<_y;h4_zbP%EWC%1&N!dbBrRHGmwz|%{BjNmapreMwY)$RXn^C;#EGyiouZwSKK+~uoqL3=?wW=Upn%w;s%KB^kvLvs+-LeQ2*sSNM^i-`-F{Pq zEgVO&&09|xHP$gG<$YVR@g(X=}0lcFYl@0AZ)tDdFB z>o{Tb^1};Vv0Tdka)-RLsOXF5!xj(ARxW*~1#9~}@#Z1`l=K`GYZJU*bnz~2>R`C9 zA*FraiVt)=mv?3^1LfTIMf7`@wEHKbFYNs{x~dMsn(+JV;AECJuW4G6*!s*99YJ@2USP^+O>S?&~ zWVd=~Fv4(DY$6#b;$92V6mkDam;5Nas2qstiXe?hjL%OTJ)-RCRWL(4iZ7XI09*%$ zIYP+jr^Suo-CN5{Ocpe#Nv(eXjI}~X{szOlNV^y3^mxvsP5rh7)bxS^4I8$+Uq!I6 z{+7bg4GZ3qhJmCmtl${sOU|inSUId*;je-E3rhx#PW&Zilee0S*gAB!#NUeAawl<)(uHkVgVu*CA`ia3uN4JW&6d;dZZ6*E{DV%P zncFLv2fXErGLNE_{BP0Z;Ixwe)84`n_EGvloF9d_*I%Q!qCy)Fl1@hR1FG+k4)3XG z1V?n>R*HLgNsWP43|u^-_nwOr-UlFQ(LtfGuCt0PU^ zA(`5$R;)}ezOh6TcU-24JEoL?xZ@d3+;I$uJARfFbh{ekEa1C8#TU9=r%9+eUVas7 z)Q!`Kf&g6Njnk@Wy#8uuAF%kv)vw=kMBbDuE3Cos6KR)6Y53E~@lpEm>&z9OEQT~T z#@Q#Q%&s{^M*~1{V`D*L^mfg=kJr=T`K`yz#g7KAjUs#^9Rz(x#YAdaMv46sTNStR zQb)ye#!NT!Qb`1p67cqzOD#Y)KEoz>u(m22KH85BwzN}~@}1zqALApV|bC0pT;mmn&eX@nL^m<$3GnEw~A^!`Ok=BUy)A9@_IlF%46Ru--|-+%GjQA z3$N3xUm9@#etP(6K*WFq=Cr9bOmb}{XM$2CuW7n`rq&N8*|}N9oP$F;Pd|U6ko78xdAoL?A(YP-H51gr*9Oc(>Rk2RSXTO zt0U~`yIW);Q89y~LHZ|+$6|CUy*_H*L;l98cadHo_6V47W&Yl^D~a@ltI^P`Nf?>j`0_;oJTFb8PIh#g(ClbqnUnfvwl`v zpih$84X&BLox`dawHrT>a9rz6SQekOR%lAWq$^mpnTnfiX`K|kYz$OLkoZpo zruy+0kB@XdDgCwAJ;@Ww9##q%=TH7&oLgiwO|sLEU-y>xx%lK>ze3?6Z`!sQyvm}D zq@s=C7CErDuDP(x>}Ni~{cCTn$)}46tv?l^+eIJQxa<+;QTp+FWcMt*4#fajq~G7!NLh`BzpFq174swVCHI?;KhlV1E*h?E0RC? zCz2bBXE!!74bQox5@j)xk!RZSXfnN|*8HOD>BTp?X_0&e4I;TSEs|fMMe-O+5Xrmp ze@Ald`MpS<-f=c?hoVSOWK=3NeJ*~H+&|}I1e%n?l(vA)f%n%Um*-*B@5zG) zeGLoEDN3qGg;&I?Sk}OtjDdAXwea3_v^e2yFlO6h|L@bCVlE}DQG$=4=2UQcTcx1S zvBC<|?-%ysZv6#f(Ulcm){5M_X_LpdHx)0LTE22YG|Za-ZP=!d0DThq`T1uh7UDX38@iJJP&NWvZx2en&%5_$cVV1Dy zj4zUeiE%zic$+(PBuUu5Csv0rUh(y~5Asg*)#+B_&o3p7|JY<4c+FqUjTSGjUP2>? z0UjRtlcs6gF>U2`Mu;Uf=&@N$o`KyZ)VqOi+e8g2livHeELfvZev;vO!LvE3a8kV_ zZSe!b>WklDwf%oP*G8d>sE1CDT-z#+BMKG4pct*HC!9XoUk&jzQQWB-koXuQ=C><3 zM##?&&`2P6C?~<5gmhVF`N!47oiY7O&xcGjuCi~nKP$Cf9C}q?Wd{MTyS6vK#?$B5 z^Y-dKl9vsP^JU*8{{=0BK`j|Hy&jB7;wyzKBE}>q!MzWfP#|S(w!2`2DXQS-0X!o`%9 z0a+k=N3dYmsgr@AAkp`}_m7|t3Muuc<~Pxn?!5bz{MkF4PlG(xkI)lb`{(|S-j&q& zBEkZ!wQ+V|*33R_EEuB(i-*w>?21dp!v;W^3bt3X*1soG(Vv?k8@C%AApj>a&of2F4-5Up0QilsP0gluC+qhjhS8G zu18;}_AS#sN`e;H(hUu{lR}sg=W%W z*lERD`8PT7RE={j)3iJ3mB@gtm(O6SE!v2<*nY<`_3TKPi%+z+lx5|`J`ca9-)#V+ zBSF6}NH4{yrek?#hO)e&jC-H{fOk2^2@7&PY zA<;!okY~YwJj;3&$g}L2i0=eAF4>Oa?<-HUDe3UD!=qcs+hL5EKWZ3 z`O($e6zgaI!o$wYAEt?x|%*{nL<=Ur`|afXA#yQ(^-X;2E56EV4%(!FF>2#wm+Ru~A*eA!w1#-l># zw2nb*6zB=;%oBu*-l!I>)QjQ({+ghTDf4DYM^<#j(TvJst=A8^ue*|qBMS|%8I=f^ zf)%%S=wM&F#|sIcGvs#t~hj?O`YN{)wF?^Ad27P1v*|H8GIWe?>ha7{x>0 zT+$d&-lf)ScqeXSo-4HWpokJwkCStQe&&M%eOh8MXhLGu6d4&Q&acMO*r9~xf@riTX;s{71Hvd2`13yW=iiC4E zT>e?WRQ=08NN~`u5y*G2gqAyM_?0`Ve>}{_IyX7AwG>2c7!^?WJO;l$=rSDKu!_7T za0`6K7=cT8k0}G4er*1faq6nsgGf^w%dyCeC-I9A7hT$C-8V^>Iq1jE)O7W$qi1eA%tv=?28VUWhkd+V1|PlOX{evHD%ASQuI0-OQ@6(D z{ENA?&YX(L%S-Wq|GV6w*($u`JqxkgL;h?9Q z^s>1SR|r7x2+th{in55U3LiOa{_=W($iicuW+lLlg)E8N?bJ|pyzk|-t^#b#9k33u6f-v*)vjz3`QL#3Vf|i z*>K)kcKcH2ks!R--y2sH4jCvb@;ffS!EqIUn`-MJZDevzI+u*cM*Jxg*X(N|+fCzd zuDH5^64W1e?=bIg{qLDwmNA8sP{>nmR--xVYaC0fCkIP|OFYy7+5tMsoM zK&;pLrn6{$39Y*pOHf~8KiCG!3%a1d?1QXqb|Zb1pG>M?A9Vx8h@bxSVnjN<`!Zhv-VR-hcM(g?P)W%=kTqf^Ghc+E(g%RT7=C;3LW8$xc81 z$(OvAQrj{vcKAsKQ^k%W@W8?l!ZD^B!cPticfFw1dCE%}2IbQ0BMWAQ_XX8=ba@X* zF>z7oQF{kOZHa2BwNumJqCrml9_2J5)nIYf8xawa!a4BH?>sa*p3RFUbAnyathK5= zhqkP#6OCvQrTH;d<3wAp&>W3_?-9Qnoz>6y$GsY%wYlgkvzZ2|Ow)XhAb8kEOtKFW z<9Sq{H!nKfa`P6{oZgX}^2q@cRO6zPitl6*`7!t^#cosL`zTKE@$fyioyglh`#XdQ znxVG$DU&FUA=69{0Dkbud5(W0Gk+8)9tDVyUnW4n!H#P`)95qi9hdZ1@%HTf3Y*n6E@{tS=~h)w zUVh!FB};3cdL8k=cXCK=&0^*GGWHv>;eiiK<6kV3`YnyE`h&ymZ{tNBrc-h8Y?TS_ zQB(uT{qL!7=?zwzJsR^QkyO*;*L%f!&-3vb;>ASW<$DjDyc@Wk-s!|?kq4=K&FbI^ zpDHi?%*SUKm!*p_FtdMS_NwTD_&2&4lS+^kpPGsr`!^3uJ|;6c`gxv5M%H>P4}_Z% z-=9ub=vy%T8bt>77AgIiPgi_7)|=ar!eKAM?eF8o3|6K0?QpD52G(wDVoI&A)|;DF z)}IAWsQ03Di2j5YFW{oGc+qaX=>NUZS;3RbPp!8`+Fhg6eg4J{RpNF42P0bb+lP2v zT@~u$3;r^BJOcW_ouk10KKmC}Ql!80nC}nIb{CdRp1Nbjd8S0t?4X9d=sh7=OX9>x z1@n<_uZt%Ew##&&KY z>k_Fk*x-{2I$*|u#l_~T)9JH``Ii(wZ_TG6E~t*J<<;9Jy`h<3;fpGXqi+`}_a?`u z6s`>(I5!bRI;&gS2u;(t_JAaFz1XrMF3qm?$NIMga6ftN-A@dyuj5UuMDCE9UUU5I z-q3((U2aKr zG5(okD7j;k%UjbJ*|a@-kw9$aWpc_Cs3?>jHyDa8ouCgk zYn4_jMO|TtI<2`M-+96SH6AiuFm=((n&P)(}1b<}o!k;*gTYoW z)dv%qT!4Gr&pr1zF#s;|o4>c7oGR1OJlg{P^lf}$$zAfmQOJ%}aPtSX_7k+%%FSiZ z`ux~2aWx<*S3|ywa%ebvSpdDf(MiNtutFUnjrkSl`H1h_^I;qYZgP18g)d>b?kryW z`J$o>n`IfZc@9?HYhTWPPJY*G04p#9O>+X0!te=tfx8T$!+zF;-8jD?9GC_JCq}Ig zeN&x{1HliC`>x#n#LQ9Qsjs33AAOiA*KK@X{f0<12qoZUzUwE*QG!BsYZ%0@5Z*H1 z%aaEeSzmUOaO8IFv1lRE^=Kg)3*vR-1F~NY66s!0=lK-UI7jGTXFkT^&7zO(*MpH9 zqR3xf@4hoNSHFze&ruPmkL~Rq^MZnL}k|O(y!_t~3tsSM3_9BKNei$4GY*^9=hu*nJL5|2QV)$z@#N{1Mqh zLEAqecP9*sjMMi4#gj`xzYX2D%0d#jn&evTGS4!sE?mRt9;DYt=l$GPEb4B{aomU9 z0Jhd%cIP2jV;We-Wc_N7Atxm^eA#6fyXH4QI9?MAqZR-XBrr#H^s$1UqLF@a3MD@e z2Punw8vX>_0dI=be4Anl(s7n0GjpFTINt!w*=eBXWyC@ww3CnNP|$%igL^m^0-Z-V zU)NhlZBD{+NF1DIgp;aBJ77mV8K2a<^|}&0^s2al>5j>9s>K_odbqg|PlJ2W=l^+`H#$CPwpeJQu0Ej?q_`-<7M%l zo0l4}W#g*GQ{WM!KNbVN%q?_T?Fw&gXF3rqhJ`C#YUkYjs(7evxQL$EZtq_ffIQTp zrik5`Zf~CTk_u!Rw|BYc11MX)@Y`oCnT(kzPG

    |I%NR}UDJpxDv$VyX}4xEkKm03P6N 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�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 literal 0 HcmV?d00001 diff --git a/packages/cel/src/re2/__fixtures__/re2-search.txt b/packages/cel/src/re2/__fixtures__/re2-search.txt new file mode 100644 index 0000000..8c4098a --- /dev/null +++ b/packages/cel/src/re2/__fixtures__/re2-search.txt @@ -0,0 +1,3779 @@ +# RE2 basic search tests built by make log +# Wed May 12 12:13:22 EDT 2021 +Regexp.SearchTests +strings +"" +"a" +regexps +"a" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:a)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"zyzzyva" +regexps +"a" +-;-;-;- +-;6-7;-;6-7 +"^(?:a)$" +-;-;-;- +-;-;-;- +"^(?:a)" +-;-;-;- +-;-;-;- +"(?:a)$" +-;-;-;- +-;6-7;-;6-7 +strings +"" +"aa" +regexps +"a+" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:a+)$" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:a+)" +-;-;-;- +0-2;0-2;0-2;0-2 +"(?:a+)$" +-;-;-;- +0-2;0-2;0-2;0-2 +strings +"" +"ab" +regexps +"(a+|b)+" +-;-;-;- +0-2 1-2;0-2 1-2;0-2 1-2;0-2 1-2 +"^(?:(a+|b)+)$" +-;-;-;- +0-2 1-2;0-2 1-2;0-2 1-2;0-2 1-2 +"^(?:(a+|b)+)" +-;-;-;- +0-2 1-2;0-2 1-2;0-2 1-2;0-2 1-2 +"(?:(a+|b)+)$" +-;-;-;- +0-2 1-2;0-2 1-2;0-2 1-2;0-2 1-2 +strings +"" +"xabcdx" +regexps +"ab|cd" +-;-;-;- +-;1-3;-;1-3 +"^(?:ab|cd)$" +-;-;-;- +-;-;-;- +"^(?:ab|cd)" +-;-;-;- +-;-;-;- +"(?:ab|cd)$" +-;-;-;- +-;-;-;- +strings +"" +"hello\ngoodbye\n" +regexps +"h.*od?" +-;-;-;- +-;0-5;-;0-5 +"^(?:h.*od?)$" +-;-;-;- +-;-;-;- +"^(?:h.*od?)" +-;-;-;- +-;0-5;-;0-5 +"(?:h.*od?)$" +-;-;-;- +-;-;-;- +strings +"" +"hello\ngoodbye\n" +regexps +"h.*o" +-;-;-;- +-;0-5;-;0-5 +"^(?:h.*o)$" +-;-;-;- +-;-;-;- +"^(?:h.*o)" +-;-;-;- +-;0-5;-;0-5 +"(?:h.*o)$" +-;-;-;- +-;-;-;- +strings +"" +"goodbye\nhello\n" +regexps +"h.*o" +-;-;-;- +-;8-13;-;8-13 +"^(?:h.*o)$" +-;-;-;- +-;-;-;- +"^(?:h.*o)" +-;-;-;- +-;-;-;- +"(?:h.*o)$" +-;-;-;- +-;-;-;- +strings +"" +"hello world" +regexps +"h.*o" +-;-;-;- +-;0-8;-;0-8 +"^(?:h.*o)$" +-;-;-;- +-;-;-;- +"^(?:h.*o)" +-;-;-;- +-;0-8;-;0-8 +"(?:h.*o)$" +-;-;-;- +-;-;-;- +strings +"" +"othello, world" +regexps +"h.*o" +-;-;-;- +-;2-11;-;2-11 +"^(?:h.*o)$" +-;-;-;- +-;-;-;- +"^(?:h.*o)" +-;-;-;- +-;-;-;- +"(?:h.*o)$" +-;-;-;- +-;-;-;- +strings +"" +"aaaaaaa" +regexps +"[^\\s\\S]" +-;-;-;- +-;-;-;- +"^(?:[^\\s\\S])$" +-;-;-;- +-;-;-;- +"^(?:[^\\s\\S])" +-;-;-;- +-;-;-;- +"(?:[^\\s\\S])$" +-;-;-;- +-;-;-;- +strings +"" +"aaaaaaa" +regexps +"a" +-;-;-;- +-;0-1;-;0-1 +"^(?:a)$" +-;-;-;- +-;-;-;- +"^(?:a)" +-;-;-;- +-;0-1;-;0-1 +"(?:a)$" +-;-;-;- +-;6-7;-;6-7 +strings +"" +"aaaaaaa" +regexps +"a*" +0-0;0-0;0-0;0-0 +0-7;0-7;0-7;0-7 +"^(?:a*)$" +0-0;0-0;0-0;0-0 +0-7;0-7;0-7;0-7 +"^(?:a*)" +0-0;0-0;0-0;0-0 +0-7;0-7;0-7;0-7 +"(?:a*)$" +0-0;0-0;0-0;0-0 +0-7;0-7;0-7;0-7 +strings +"" +"" +regexps +"a*" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:a*)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:a*)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:a*)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"xabcdx" +regexps +"ab|cd" +-;-;-;- +-;1-3;-;1-3 +"^(?:ab|cd)$" +-;-;-;- +-;-;-;- +"^(?:ab|cd)" +-;-;-;- +-;-;-;- +"(?:ab|cd)$" +-;-;-;- +-;-;-;- +strings +"" +"cab" +regexps +"a" +-;-;-;- +-;1-2;-;1-2 +"^(?:a)$" +-;-;-;- +-;-;-;- +"^(?:a)" +-;-;-;- +-;-;-;- +"(?:a)$" +-;-;-;- +-;-;-;- +strings +"" +"cab" +regexps +"a*b" +-;-;-;- +-;1-3;-;1-3 +"^(?:a*b)$" +-;-;-;- +-;-;-;- +"^(?:a*b)" +-;-;-;- +-;-;-;- +"(?:a*b)$" +-;-;-;- +-;1-3;-;1-3 +strings +"" +"x" +regexps +"((((((((((((((((((((x))))))))))))))))))))" +-;-;-;- +0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 +"^(?:((((((((((((((((((((x)))))))))))))))))))))$" +-;-;-;- +0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 +"^(?:((((((((((((((((((((x)))))))))))))))))))))" +-;-;-;- +0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 +"(?:((((((((((((((((((((x)))))))))))))))))))))$" +-;-;-;- +0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1;0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 0-1 +strings +"" +"xxxabcdxxx" +regexps +"[abcd]" +-;-;-;- +-;3-4;-;3-4 +"^(?:[abcd])$" +-;-;-;- +-;-;-;- +"^(?:[abcd])" +-;-;-;- +-;-;-;- +"(?:[abcd])$" +-;-;-;- +-;-;-;- +strings +"" +"xxxabcdxxx" +regexps +"[^x]" +-;-;-;- +-;3-4;-;3-4 +"^(?:[^x])$" +-;-;-;- +-;-;-;- +"^(?:[^x])" +-;-;-;- +-;-;-;- +"(?:[^x])$" +-;-;-;- +-;-;-;- +strings +"" +"xxxabcdxxx" +regexps +"[abcd]+" +-;-;-;- +-;3-7;-;3-7 +"^(?:[abcd]+)$" +-;-;-;- +-;-;-;- +"^(?:[abcd]+)" +-;-;-;- +-;-;-;- +"(?:[abcd]+)$" +-;-;-;- +-;-;-;- +strings +"" +"xxxabcdxxx" +regexps +"[^x]+" +-;-;-;- +-;3-7;-;3-7 +"^(?:[^x]+)$" +-;-;-;- +-;-;-;- +"^(?:[^x]+)" +-;-;-;- +-;-;-;- +"(?:[^x]+)$" +-;-;-;- +-;-;-;- +strings +"" +"fo" +regexps +"(fo|foo)" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:(fo|foo))$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:(fo|foo))" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"(?:(fo|foo))$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +strings +"" +"foo" +regexps +"(foo|fo)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(foo|fo))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(foo|fo))" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:(foo|fo))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"aA" +regexps +"aa" +-;-;-;- +-;-;-;- +"^(?:aa)$" +-;-;-;- +-;-;-;- +"^(?:aa)" +-;-;-;- +-;-;-;- +"(?:aa)$" +-;-;-;- +-;-;-;- +strings +"" +"Aa" +regexps +"a" +-;-;-;- +-;1-2;-;1-2 +"^(?:a)$" +-;-;-;- +-;-;-;- +"^(?:a)" +-;-;-;- +-;-;-;- +"(?:a)$" +-;-;-;- +-;1-2;-;1-2 +strings +"" +"A" +regexps +"a" +-;-;-;- +-;-;-;- +"^(?:a)$" +-;-;-;- +-;-;-;- +"^(?:a)" +-;-;-;- +-;-;-;- +"(?:a)$" +-;-;-;- +-;-;-;- +strings +"" +"abc" +regexps +"ABC" +-;-;-;- +-;-;-;- +"^(?:ABC)$" +-;-;-;- +-;-;-;- +"^(?:ABC)" +-;-;-;- +-;-;-;- +"(?:ABC)$" +-;-;-;- +-;-;-;- +strings +"" +"XABCY" +regexps +"abc" +-;-;-;- +-;-;-;- +"^(?:abc)$" +-;-;-;- +-;-;-;- +"^(?:abc)" +-;-;-;- +-;-;-;- +"(?:abc)$" +-;-;-;- +-;-;-;- +strings +"" +"xabcy" +regexps +"ABC" +-;-;-;- +-;-;-;- +"^(?:ABC)$" +-;-;-;- +-;-;-;- +"^(?:ABC)" +-;-;-;- +-;-;-;- +"(?:ABC)$" +-;-;-;- +-;-;-;- +strings +"" +"foo" +regexps +"foo|bar|[A-Z]" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:foo|bar|[A-Z])$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:foo|bar|[A-Z])" +-;-;-;- +0-3;0-3;0-3;0-3 +"(?:foo|bar|[A-Z])$" +-;-;-;- +0-3;0-3;0-3;0-3 +strings +"" +"foo" +regexps +"^(foo|bar|[A-Z])" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(foo|bar|[A-Z]))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(foo|bar|[A-Z]))" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:^(foo|bar|[A-Z]))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"foo\n" +regexps +"(foo|bar|[A-Z])$" +-;-;-;- +-;-;-;- +"^(?:(foo|bar|[A-Z])$)$" +-;-;-;- +-;-;-;- +"^(?:(foo|bar|[A-Z])$)" +-;-;-;- +-;-;-;- +"(?:(foo|bar|[A-Z])$)$" +-;-;-;- +-;-;-;- +strings +"" +"foo" +regexps +"(foo|bar|[A-Z])$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(foo|bar|[A-Z])$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(foo|bar|[A-Z])$)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:(foo|bar|[A-Z])$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"foo\n" +regexps +"^(foo|bar|[A-Z])$" +-;-;-;- +-;-;-;- +"^(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +-;-;-;- +"^(?:^(foo|bar|[A-Z])$)" +-;-;-;- +-;-;-;- +"(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +-;-;-;- +strings +"" +"foo" +regexps +"^(foo|bar|[A-Z])$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(foo|bar|[A-Z])$)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"bar" +regexps +"^(foo|bar|[A-Z])$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(foo|bar|[A-Z])$)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"X" +regexps +"^(foo|bar|[A-Z])$" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +"^(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +"^(?:^(foo|bar|[A-Z])$)" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +"(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +strings +"" +"XY" +regexps +"^(foo|bar|[A-Z])$" +-;-;-;- +-;-;-;- +"^(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +-;-;-;- +"^(?:^(foo|bar|[A-Z])$)" +-;-;-;- +-;-;-;- +"(?:^(foo|bar|[A-Z])$)$" +-;-;-;- +-;-;-;- +strings +"" +"fo" +regexps +"^(fo|foo)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:^(fo|foo)$)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:^(fo|foo)$)" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"(?:^(fo|foo)$)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +strings +"" +"foo" +regexps +"^(fo|foo)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(fo|foo)$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^(fo|foo)$)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:^(fo|foo)$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"fo" +regexps +"^^(fo|foo)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:^^(fo|foo)$)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:^^(fo|foo)$)" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"(?:^^(fo|foo)$)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +strings +"" +"foo" +regexps +"^^(fo|foo)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^^(fo|foo)$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^^(fo|foo)$)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:^^(fo|foo)$)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"" +regexps +"^$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"" +regexps +"^^$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"" +regexps +"^$$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"^$$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"" +regexps +"^^$$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^$$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^^$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^^$$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^$$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^$$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^^$$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"" +regexps +"^^^^^^^^$$$$$$$$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^^^^^^^$$$$$$$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^^^^^^^$$$$$$$$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^^^^^^^^$$$$$$$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^" +0-0;0-0;0-0;0-0 +-;0-0;-;0-0 +"^(?:^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^)" +0-0;0-0;0-0;0-0 +-;0-0;-;0-0 +"(?:^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"$" +0-0;0-0;0-0;0-0 +-;1-1;-;1-1 +"^(?:$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:$)$" +0-0;0-0;0-0;0-0 +-;1-1;-;1-1 +strings +"" +"nofoo foo that" +regexps +"\\bfoo\\b" +-;-;-;- +-;6-9;-;6-9 +"^(?:\\bfoo\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bfoo\\b)" +-;-;-;- +-;-;-;- +"(?:\\bfoo\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"faoa x" +regexps +"a\\b" +-;-;-;- +-;3-4;-;3-4 +"^(?:a\\b)$" +-;-;-;- +-;-;-;- +"^(?:a\\b)" +-;-;-;- +-;-;-;- +"(?:a\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"bar x" +regexps +"\\bbar" +-;-;-;- +-;0-3;-;0-3 +"^(?:\\bbar)$" +-;-;-;- +-;-;-;- +"^(?:\\bbar)" +-;-;-;- +-;0-3;-;0-3 +"(?:\\bbar)$" +-;-;-;- +-;-;-;- +strings +"" +"foo\nbar x" +regexps +"\\bbar" +-;-;-;- +-;4-7;-;4-7 +"^(?:\\bbar)$" +-;-;-;- +-;-;-;- +"^(?:\\bbar)" +-;-;-;- +-;-;-;- +"(?:\\bbar)$" +-;-;-;- +-;-;-;- +strings +"" +"foobar" +regexps +"bar\\b" +-;-;-;- +-;3-6;-;3-6 +"^(?:bar\\b)$" +-;-;-;- +-;-;-;- +"^(?:bar\\b)" +-;-;-;- +-;-;-;- +"(?:bar\\b)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"foobar\nxxx" +regexps +"bar\\b" +-;-;-;- +-;3-6;-;3-6 +"^(?:bar\\b)$" +-;-;-;- +-;-;-;- +"^(?:bar\\b)" +-;-;-;- +-;-;-;- +"(?:bar\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"foo" +regexps +"(foo|bar|[A-Z])\\b" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(foo|bar|[A-Z])\\b)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"foo\n" +regexps +"(foo|bar|[A-Z])\\b" +-;-;-;- +-;0-3 0-3;-;0-3 0-3 +"^(?:(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +"^(?:(foo|bar|[A-Z])\\b)" +-;-;-;- +-;0-3 0-3;-;0-3 0-3 +"(?:(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"\\b" +-;-;-;- +-;-;-;- +"^(?:\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b)" +-;-;-;- +-;-;-;- +"(?:\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"\\b" +-;-;-;- +-;0-0;-;0-0 +"^(?:\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b)" +-;-;-;- +-;0-0;-;0-0 +"(?:\\b)$" +-;-;-;- +-;1-1;-;1-1 +strings +"" +"foo" +regexps +"\\b(foo|bar|[A-Z])" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z]))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z]))" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:\\b(foo|bar|[A-Z]))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"X" +regexps +"\\b(foo|bar|[A-Z])\\b" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +"^(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +"^(?:\\b(foo|bar|[A-Z])\\b)" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +"(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-1 0-1;0-1 0-1;0-1 0-1;0-1 0-1 +strings +"" +"XY" +regexps +"\\b(foo|bar|[A-Z])\\b" +-;-;-;- +-;-;-;- +"^(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b(foo|bar|[A-Z])\\b)" +-;-;-;- +-;-;-;- +"(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"bar" +regexps +"\\b(foo|bar|[A-Z])\\b" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z])\\b)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"foo" +regexps +"\\b(foo|bar|[A-Z])\\b" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z])\\b)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"foo\n" +regexps +"\\b(foo|bar|[A-Z])\\b" +-;-;-;- +-;0-3 0-3;-;0-3 0-3 +"^(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b(foo|bar|[A-Z])\\b)" +-;-;-;- +-;0-3 0-3;-;0-3 0-3 +"(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"ffoo bbar N x" +regexps +"\\b(foo|bar|[A-Z])\\b" +-;-;-;- +-;10-11 10-11;-;10-11 10-11 +"^(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b(foo|bar|[A-Z])\\b)" +-;-;-;- +-;-;-;- +"(?:\\b(foo|bar|[A-Z])\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"fo" +regexps +"\\b(fo|foo)\\b" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:\\b(fo|foo)\\b)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:\\b(fo|foo)\\b)" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"(?:\\b(fo|foo)\\b)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +strings +"" +"foo" +regexps +"\\b(fo|foo)\\b" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(fo|foo)\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:\\b(fo|foo)\\b)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:\\b(fo|foo)\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"" +regexps +"\\b\\b" +-;-;-;- +-;-;-;- +"^(?:\\b\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b\\b)" +-;-;-;- +-;-;-;- +"(?:\\b\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"\\b\\b" +-;-;-;- +-;0-0;-;0-0 +"^(?:\\b\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\b\\b)" +-;-;-;- +-;0-0;-;0-0 +"(?:\\b\\b)$" +-;-;-;- +-;1-1;-;1-1 +strings +"" +"" +regexps +"\\b$" +-;-;-;- +-;-;-;- +"^(?:\\b$)$" +-;-;-;- +-;-;-;- +"^(?:\\b$)" +-;-;-;- +-;-;-;- +"(?:\\b$)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"\\b$" +-;-;-;- +-;1-1;-;1-1 +"^(?:\\b$)$" +-;-;-;- +-;-;-;- +"^(?:\\b$)" +-;-;-;- +-;-;-;- +"(?:\\b$)$" +-;-;-;- +-;1-1;-;1-1 +strings +"" +"y x" +regexps +"\\b$" +-;-;-;- +-;3-3;-;3-3 +"^(?:\\b$)$" +-;-;-;- +-;-;-;- +"^(?:\\b$)" +-;-;-;- +-;-;-;- +"(?:\\b$)$" +-;-;-;- +-;3-3;-;3-3 +strings +"" +"x" +regexps +"\\b.$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\b.$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\b.$)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\b.$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"fo" +regexps +"^\\b(fo|foo)\\b" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:^\\b(fo|foo)\\b)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"^(?:^\\b(fo|foo)\\b)" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +"(?:^\\b(fo|foo)\\b)$" +-;-;-;- +0-2 0-2;0-2 0-2;0-2 0-2;0-2 0-2 +strings +"" +"foo" +regexps +"^\\b(fo|foo)\\b" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^\\b(fo|foo)\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:^\\b(fo|foo)\\b)" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"(?:^\\b(fo|foo)\\b)$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"" +regexps +"^\\b" +-;-;-;- +-;-;-;- +"^(?:^\\b)$" +-;-;-;- +-;-;-;- +"^(?:^\\b)" +-;-;-;- +-;-;-;- +"(?:^\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^\\b" +-;-;-;- +-;0-0;-;0-0 +"^(?:^\\b)$" +-;-;-;- +-;-;-;- +"^(?:^\\b)" +-;-;-;- +-;0-0;-;0-0 +"(?:^\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"^\\b\\b" +-;-;-;- +-;-;-;- +"^(?:^\\b\\b)$" +-;-;-;- +-;-;-;- +"^(?:^\\b\\b)" +-;-;-;- +-;-;-;- +"(?:^\\b\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^\\b\\b" +-;-;-;- +-;0-0;-;0-0 +"^(?:^\\b\\b)$" +-;-;-;- +-;-;-;- +"^(?:^\\b\\b)" +-;-;-;- +-;0-0;-;0-0 +"(?:^\\b\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"^\\b$" +-;-;-;- +-;-;-;- +"^(?:^\\b$)$" +-;-;-;- +-;-;-;- +"^(?:^\\b$)" +-;-;-;- +-;-;-;- +"(?:^\\b$)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^\\b$" +-;-;-;- +-;-;-;- +"^(?:^\\b$)$" +-;-;-;- +-;-;-;- +"^(?:^\\b$)" +-;-;-;- +-;-;-;- +"(?:^\\b$)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^\\b.$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:^\\b.$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:^\\b.$)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:^\\b.$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"x" +regexps +"^\\b.\\b$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:^\\b.\\b$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:^\\b.\\b$)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:^\\b.\\b$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"" +regexps +"^^^^^^^^\\b$$$$$$$" +-;-;-;- +-;-;-;- +"^(?:^^^^^^^^\\b$$$$$$$)$" +-;-;-;- +-;-;-;- +"^(?:^^^^^^^^\\b$$$$$$$)" +-;-;-;- +-;-;-;- +"(?:^^^^^^^^\\b$$$$$$$)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^^^^^^^^\\b.$$$$$$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:^^^^^^^^\\b.$$$$$$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:^^^^^^^^\\b.$$$$$$)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:^^^^^^^^\\b.$$$$$$)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"x" +regexps +"^^^^^^^^\\b$$$$$$$" +-;-;-;- +-;-;-;- +"^(?:^^^^^^^^\\b$$$$$$$)$" +-;-;-;- +-;-;-;- +"^(?:^^^^^^^^\\b$$$$$$$)" +-;-;-;- +-;-;-;- +"(?:^^^^^^^^\\b$$$$$$$)$" +-;-;-;- +-;-;-;- +strings +"" +"n foo xfoox that" +regexps +"\\Bfoo\\B" +-;-;-;- +-;7-10;-;7-10 +"^(?:\\Bfoo\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\Bfoo\\B)" +-;-;-;- +-;-;-;- +"(?:\\Bfoo\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"faoa x" +regexps +"a\\B" +-;-;-;- +-;1-2;-;1-2 +"^(?:a\\B)$" +-;-;-;- +-;-;-;- +"^(?:a\\B)" +-;-;-;- +-;-;-;- +"(?:a\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"bar x" +regexps +"\\Bbar" +-;-;-;- +-;-;-;- +"^(?:\\Bbar)$" +-;-;-;- +-;-;-;- +"^(?:\\Bbar)" +-;-;-;- +-;-;-;- +"(?:\\Bbar)$" +-;-;-;- +-;-;-;- +strings +"" +"foo\nbar x" +regexps +"\\Bbar" +-;-;-;- +-;-;-;- +"^(?:\\Bbar)$" +-;-;-;- +-;-;-;- +"^(?:\\Bbar)" +-;-;-;- +-;-;-;- +"(?:\\Bbar)$" +-;-;-;- +-;-;-;- +strings +"" +"foobar" +regexps +"bar\\B" +-;-;-;- +-;-;-;- +"^(?:bar\\B)$" +-;-;-;- +-;-;-;- +"^(?:bar\\B)" +-;-;-;- +-;-;-;- +"(?:bar\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"foobar\nxxx" +regexps +"bar\\B" +-;-;-;- +-;-;-;- +"^(?:bar\\B)$" +-;-;-;- +-;-;-;- +"^(?:bar\\B)" +-;-;-;- +-;-;-;- +"(?:bar\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"foox" +regexps +"(foo|bar|[A-Z])\\B" +-;-;-;- +-;0-3 0-3;-;0-3 0-3 +"^(?:(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:(foo|bar|[A-Z])\\B)" +-;-;-;- +-;0-3 0-3;-;0-3 0-3 +"(?:(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"foo\n" +regexps +"(foo|bar|[A-Z])\\B" +-;-;-;- +-;-;-;- +"^(?:(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"\\B" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:\\B)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"\\B" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"foo" +regexps +"\\B(foo|bar|[A-Z])" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z]))$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z]))" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z]))$" +-;-;-;- +-;-;-;- +strings +"" +"xXy" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;1-2 1-2;-;1-2 1-2 +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"XY" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"XYZ" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;1-2 1-2;-;1-2 1-2 +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"abara" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;1-4 1-4;-;1-4 1-4 +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"xfoo_" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;1-4 1-4;-;1-4 1-4 +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"xfoo\n" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"foo bar vNx" +regexps +"\\B(foo|bar|[A-Z])\\B" +-;-;-;- +-;9-10 9-10;-;9-10 9-10 +"^(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|bar|[A-Z])\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|bar|[A-Z])\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"xfoo" +regexps +"\\B(fo|foo)\\B" +-;-;-;- +-;1-3 1-3;-;1-3 1-3 +"^(?:\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(fo|foo)\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"xfooo" +regexps +"\\B(foo|fo)\\B" +-;-;-;- +-;1-4 1-4;-;1-4 1-4 +"^(?:\\B(foo|fo)\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(foo|fo)\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(foo|fo)\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"\\B\\B" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:\\B\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:\\B\\B)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:\\B\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"\\B\\B" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B\\B)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:\\B\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"" +regexps +"\\B$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:\\B$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:\\B$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:\\B$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"\\B$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:\\B$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"y x" +regexps +"\\B$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:\\B$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:\\B$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"\\B.$" +-;-;-;- +-;-;-;- +"^(?:\\B.$)$" +-;-;-;- +-;-;-;- +"^(?:\\B.$)" +-;-;-;- +-;-;-;- +"(?:\\B.$)$" +-;-;-;- +-;-;-;- +strings +"" +"fo" +regexps +"^\\B(fo|foo)\\B" +-;-;-;- +-;-;-;- +"^(?:^\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +"^(?:^\\B(fo|foo)\\B)" +-;-;-;- +-;-;-;- +"(?:^\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"foo" +regexps +"^\\B(fo|foo)\\B" +-;-;-;- +-;-;-;- +"^(?:^\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +"^(?:^\\B(fo|foo)\\B)" +-;-;-;- +-;-;-;- +"(?:^\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"^\\B" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^\\B)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^\\B" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^\\B)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"" +regexps +"^\\B\\B" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^\\B\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^\\B\\B)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^\\B\\B)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^\\B\\B" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^\\B\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^\\B\\B)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^\\B\\B)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"" +regexps +"^\\B$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^\\B$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^\\B$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^\\B$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^\\B$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^\\B$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^\\B$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^\\B$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"^\\B.$" +-;-;-;- +-;-;-;- +"^(?:^\\B.$)$" +-;-;-;- +-;-;-;- +"^(?:^\\B.$)" +-;-;-;- +-;-;-;- +"(?:^\\B.$)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^\\B.\\B$" +-;-;-;- +-;-;-;- +"^(?:^\\B.\\B$)$" +-;-;-;- +-;-;-;- +"^(?:^\\B.\\B$)" +-;-;-;- +-;-;-;- +"(?:^\\B.\\B$)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"^^^^^^^^\\B$$$$$$$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^^^^^^^\\B$$$$$$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^^^^^^^^\\B$$$$$$$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^^^^^^^^\\B$$$$$$$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^^^^^^^^\\B.$$$$$$" +-;-;-;- +-;-;-;- +"^(?:^^^^^^^^\\B.$$$$$$)$" +-;-;-;- +-;-;-;- +"^(?:^^^^^^^^\\B.$$$$$$)" +-;-;-;- +-;-;-;- +"(?:^^^^^^^^\\B.$$$$$$)$" +-;-;-;- +-;-;-;- +strings +"" +"x" +regexps +"^^^^^^^^\\B$$$$$$$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^^^^^^^\\B$$$$$$$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^^^^^^^\\B$$$$$$$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^^^^^^^^\\B$$$$$$$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"\\bx\\b" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\bx\\b)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\bx\\b)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\bx\\b)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"x>" +regexps +"\\bx\\b" +-;-;-;- +-;0-1;-;0-1 +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;0-1;-;0-1 +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"\\bx\\b" +-;-;-;- +-;1-2;-;1-2 +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"ax" +regexps +"\\bx\\b" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"xb" +regexps +"\\bx\\b" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"axb" +regexps +"\\bx\\b" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"«x" +regexps +"\\bx\\b" +-;-;-;- +-;2-3;-;2-3 +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;2-3;-;2-3 +strings +"" +"x»" +regexps +"\\bx\\b" +-;-;-;- +-;0-1;-;0-1 +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;0-1;-;0-1 +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"«x»" +regexps +"\\bx\\b" +-;-;-;- +-;2-3;-;2-3 +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"axb" +regexps +"\\bx\\b" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"áxβ" +regexps +"\\bx\\b" +-;-;-;- +-;2-3;-;2-3 +"^(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +"^(?:\\bx\\b)" +-;-;-;- +-;-;-;- +"(?:\\bx\\b)$" +-;-;-;- +-;-;-;- +strings +"" +"axb" +regexps +"\\Bx\\B" +-;-;-;- +-;1-2;-;1-2 +"^(?:\\Bx\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\Bx\\B)" +-;-;-;- +-;-;-;- +"(?:\\Bx\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"áxβ" +regexps +"\\Bx\\B" +-;-;-;- +-;-;-;- +"^(?:\\Bx\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\Bx\\B)" +-;-;-;- +-;-;-;- +"(?:\\Bx\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"" +regexps +"^$^$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$^$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^$^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"" +regexps +"^$^" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$^)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:^$^)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:^$^)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"" +regexps +"$^$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:$^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"^(?:$^$)" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +"(?:$^$)$" +0-0;0-0;0-0;0-0 +0-0;0-0;0-0;0-0 +strings +"" +"x" +regexps +"^$^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"^$^" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x" +regexps +"$^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x\ny" +regexps +"^$^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x\ny" +regexps +"^$^" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x\ny" +regexps +"$^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x\n\ny" +regexps +"^$^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x\n\ny" +regexps +"^$^" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^$^)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:^$^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"x\n\ny" +regexps +"$^$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:$^$)" +0-0;0-0;0-0;0-0 +-;-;-;- +"(?:$^$)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"foo$bar" +regexps +"^(foo\\$)$" +-;-;-;- +-;-;-;- +"^(?:^(foo\\$)$)$" +-;-;-;- +-;-;-;- +"^(?:^(foo\\$)$)" +-;-;-;- +-;-;-;- +"(?:^(foo\\$)$)$" +-;-;-;- +-;-;-;- +strings +"" +"foo$bar" +regexps +"(foo\\$)" +-;-;-;- +-;0-4 0-4;-;0-4 0-4 +"^(?:(foo\\$))$" +-;-;-;- +-;-;-;- +"^(?:(foo\\$))" +-;-;-;- +-;0-4 0-4;-;0-4 0-4 +"(?:(foo\\$))$" +-;-;-;- +-;-;-;- +strings +"" +"abc" +regexps +"^...$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:^...$)$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:^...$)" +-;-;-;- +0-3;0-3;0-3;0-3 +"(?:^...$)$" +-;-;-;- +0-3;0-3;0-3;0-3 +strings +"" +"本" +regexps +"^本$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:^本$)$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:^本$)" +-;-;-;- +0-3;0-3;0-3;0-3 +"(?:^本$)$" +-;-;-;- +0-3;0-3;0-3;0-3 +strings +"" +"日本語" +regexps +"^...$" +-;-;-;- +0-9;0-9;0-9;0-9 +"^(?:^...$)$" +-;-;-;- +0-9;0-9;0-9;0-9 +"^(?:^...$)" +-;-;-;- +0-9;0-9;0-9;0-9 +"(?:^...$)$" +-;-;-;- +0-9;0-9;0-9;0-9 +strings +"" +".本." +regexps +"^...$" +-;-;-;- +0-5;0-5;0-5;0-5 +"^(?:^...$)$" +-;-;-;- +0-5;0-5;0-5;0-5 +"^(?:^...$)" +-;-;-;- +0-5;0-5;0-5;0-5 +"(?:^...$)$" +-;-;-;- +0-5;0-5;0-5;0-5 +strings +"" +"本" +regexps +"^\\C\\C\\C$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:^\\C\\C\\C$)$" +-;-;-;- +0-3;0-3;0-3;0-3 +"^(?:^\\C\\C\\C$)" +-;-;-;- +0-3;0-3;0-3;0-3 +"(?:^\\C\\C\\C$)$" +-;-;-;- +0-3;0-3;0-3;0-3 +strings +"" +"本" +regexps +"^\\C$" +-;-;-;- +-;-;-;- +"^(?:^\\C$)$" +-;-;-;- +-;-;-;- +"^(?:^\\C$)" +-;-;-;- +-;-;-;- +"(?:^\\C$)$" +-;-;-;- +-;-;-;- +strings +"" +"日本語" +regexps +"^\\C\\C\\C$" +-;-;-;- +-;-;-;- +"^(?:^\\C\\C\\C$)$" +-;-;-;- +-;-;-;- +"^(?:^\\C\\C\\C$)" +-;-;-;- +-;-;-;- +"(?:^\\C\\C\\C$)$" +-;-;-;- +-;-;-;- +strings +"" +"日本語" +regexps +"^...$" +-;-;-;- +0-9;0-9;0-9;0-9 +"^(?:^...$)$" +-;-;-;- +0-9;0-9;0-9;0-9 +"^(?:^...$)" +-;-;-;- +0-9;0-9;0-9;0-9 +"(?:^...$)$" +-;-;-;- +0-9;0-9;0-9;0-9 +strings +"" +"日本語" +regexps +"^.........$" +-;-;-;- +-;-;-;- +"^(?:^.........$)$" +-;-;-;- +-;-;-;- +"^(?:^.........$)" +-;-;-;- +-;-;-;- +"(?:^.........$)$" +-;-;-;- +-;-;-;- +strings +"" +".本." +regexps +"^...$" +-;-;-;- +0-5;0-5;0-5;0-5 +"^(?:^...$)$" +-;-;-;- +0-5;0-5;0-5;0-5 +"^(?:^...$)" +-;-;-;- +0-5;0-5;0-5;0-5 +"(?:^...$)$" +-;-;-;- +0-5;0-5;0-5;0-5 +strings +"" +".本." +regexps +"^.....$" +-;-;-;- +-;-;-;- +"^(?:^.....$)$" +-;-;-;- +-;-;-;- +"^(?:^.....$)" +-;-;-;- +-;-;-;- +"(?:^.....$)$" +-;-;-;- +-;-;-;- +strings +"" +"xfooo" +regexps +"\\B(fo|foo)\\B" +-;-;-;- +-;1-3 1-3;-;1-4 1-4 +"^(?:\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +"^(?:\\B(fo|foo)\\B)" +-;-;-;- +-;-;-;- +"(?:\\B(fo|foo)\\B)$" +-;-;-;- +-;-;-;- +strings +"" +"foo" +regexps +"(fo|foo)" +-;-;-;- +0-3 0-3;0-2 0-2;0-3 0-3;0-3 0-3 +"^(?:(fo|foo))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +"^(?:(fo|foo))" +-;-;-;- +0-3 0-3;0-2 0-2;0-3 0-3;0-3 0-3 +"(?:(fo|foo))$" +-;-;-;- +0-3 0-3;0-3 0-3;0-3 0-3;0-3 0-3 +strings +"" +"a" +regexps +"\\141" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\141)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\141)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\141)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"0" +regexps +"\\060" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\060)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\060)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\060)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"00" +regexps +"\\0600" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:\\0600)$" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:\\0600)" +-;-;-;- +0-2;0-2;0-2;0-2 +"(?:\\0600)$" +-;-;-;- +0-2;0-2;0-2;0-2 +strings +"" +"08" +regexps +"\\608" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:\\608)$" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:\\608)" +-;-;-;- +0-2;0-2;0-2;0-2 +"(?:\\608)$" +-;-;-;- +0-2;0-2;0-2;0-2 +strings +"" +"" +regexps +"\\01" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\01)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\01)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\01)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"8" +regexps +"\\018" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:\\018)$" +-;-;-;- +0-2;0-2;0-2;0-2 +"^(?:\\018)" +-;-;-;- +0-2;0-2;0-2;0-2 +"(?:\\018)$" +-;-;-;- +0-2;0-2;0-2;0-2 +strings +"" +"a" +regexps +"\\x{61}" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\x{61})$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\x{61})" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\x{61})$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"\\x61" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\x61)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\x61)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\x61)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"\\x{00000061}" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\x{00000061})$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:\\x{00000061})" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:\\x{00000061})$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"aαβb" +regexps +"\\p{Greek}+" +-;-;-;- +-;1-5;-;1-5 +"^(?:\\p{Greek}+)$" +-;-;-;- +-;-;-;- +"^(?:\\p{Greek}+)" +-;-;-;- +-;-;-;- +"(?:\\p{Greek}+)$" +-;-;-;- +-;-;-;- +strings +"" +"aαβb" +regexps +"\\P{Greek}+" +-;-;-;- +-;0-1;-;0-1 +"^(?:\\P{Greek}+)$" +-;-;-;- +-;-;-;- +"^(?:\\P{Greek}+)" +-;-;-;- +-;0-1;-;0-1 +"(?:\\P{Greek}+)$" +-;-;-;- +-;5-6;-;5-6 +strings +"" +"aαβb" +regexps +"\\p{^Greek}+" +-;-;-;- +-;0-1;-;0-1 +"^(?:\\p{^Greek}+)$" +-;-;-;- +-;-;-;- +"^(?:\\p{^Greek}+)" +-;-;-;- +-;0-1;-;0-1 +"(?:\\p{^Greek}+)$" +-;-;-;- +-;5-6;-;5-6 +strings +"" +"aαβb" +regexps +"\\P{^Greek}+" +-;-;-;- +-;1-5;-;1-5 +"^(?:\\P{^Greek}+)$" +-;-;-;- +-;-;-;- +"^(?:\\P{^Greek}+)" +-;-;-;- +-;-;-;- +"(?:\\P{^Greek}+)$" +-;-;-;- +-;-;-;- +strings +"" +"abc123" +regexps +"[^0-9]+" +-;-;-;- +-;0-3;-;0-3 +"^(?:[^0-9]+)$" +-;-;-;- +-;-;-;- +"^(?:[^0-9]+)" +-;-;-;- +-;0-3;-;0-3 +"(?:[^0-9]+)$" +-;-;-;- +-;-;-;- +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\p{Nd}+" +-;-;-;- +-;3-6;-;3-6 +"^(?:\\p{Nd}+)$" +-;-;-;- +-;-;-;- +"^(?:\\p{Nd}+)" +-;-;-;- +-;-;-;- +"(?:\\p{Nd}+)$" +-;-;-;- +-;-;-;- +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\p{^Nd}+" +-;-;-;- +-;0-3;-;0-3 +"^(?:\\p{^Nd}+)$" +-;-;-;- +-;-;-;- +"^(?:\\p{^Nd}+)" +-;-;-;- +-;0-3;-;0-3 +"(?:\\p{^Nd}+)$" +-;-;-;- +-;6-22;-;6-22 +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\P{Nd}+" +-;-;-;- +-;0-3;-;0-3 +"^(?:\\P{Nd}+)$" +-;-;-;- +-;-;-;- +"^(?:\\P{Nd}+)" +-;-;-;- +-;0-3;-;0-3 +"(?:\\P{Nd}+)$" +-;-;-;- +-;6-22;-;6-22 +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\P{^Nd}+" +-;-;-;- +-;3-6;-;3-6 +"^(?:\\P{^Nd}+)$" +-;-;-;- +-;-;-;- +"^(?:\\P{^Nd}+)" +-;-;-;- +-;-;-;- +"(?:\\P{^Nd}+)$" +-;-;-;- +-;-;-;- +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\pN+" +-;-;-;- +-;3-22;-;3-22 +"^(?:\\pN+)$" +-;-;-;- +-;-;-;- +"^(?:\\pN+)" +-;-;-;- +-;-;-;- +"(?:\\pN+)$" +-;-;-;- +-;3-22;-;3-22 +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\p{N}+" +-;-;-;- +-;3-22;-;3-22 +"^(?:\\p{N}+)$" +-;-;-;- +-;-;-;- +"^(?:\\p{N}+)" +-;-;-;- +-;-;-;- +"(?:\\p{N}+)$" +-;-;-;- +-;3-22;-;3-22 +strings +"" +"abc123²³¼½¾₀₉" +regexps +"\\p{^N}+" +-;-;-;- +-;0-3;-;0-3 +"^(?:\\p{^N}+)$" +-;-;-;- +-;-;-;- +"^(?:\\p{^N}+)" +-;-;-;- +-;0-3;-;0-3 +"(?:\\p{^N}+)$" +-;-;-;- +-;-;-;- +strings +"" +"abc123" +regexps +"\\p{Any}+" +-;-;-;- +0-6;0-6;0-6;0-6 +"^(?:\\p{Any}+)$" +-;-;-;- +0-6;0-6;0-6;0-6 +"^(?:\\p{Any}+)" +-;-;-;- +0-6;0-6;0-6;0-6 +"(?:\\p{Any}+)$" +-;-;-;- +0-6;0-6;0-6;0-6 +strings +"" +"@AaB" +regexps +"(?i)[@-A]+" +-;-;-;- +-;0-3;-;0-3 +"^(?:(?i)[@-A]+)$" +-;-;-;- +-;-;-;- +"^(?:(?i)[@-A]+)" +-;-;-;- +-;0-3;-;0-3 +"(?:(?i)[@-A]+)$" +-;-;-;- +-;-;-;- +strings +"" +"aAzZ" +regexps +"(?i)[A-Z]+" +-;-;-;- +0-4;0-4;0-4;0-4 +"^(?:(?i)[A-Z]+)$" +-;-;-;- +0-4;0-4;0-4;0-4 +"^(?:(?i)[A-Z]+)" +-;-;-;- +0-4;0-4;0-4;0-4 +"(?:(?i)[A-Z]+)$" +-;-;-;- +0-4;0-4;0-4;0-4 +strings +"" +"Aa\\" +regexps +"(?i)[^\\\\]+" +-;-;-;- +-;0-2;-;0-2 +"^(?:(?i)[^\\\\]+)$" +-;-;-;- +-;-;-;- +"^(?:(?i)[^\\\\]+)" +-;-;-;- +-;0-2;-;0-2 +"(?:(?i)[^\\\\]+)$" +-;-;-;- +-;-;-;- +strings +"" +"acegikmoqsuwyACEGIKMOQSUWY" +regexps +"(?i)[acegikmoqsuwy]+" +-;-;-;- +0-26;0-26;0-26;0-26 +"^(?:(?i)[acegikmoqsuwy]+)$" +-;-;-;- +0-26;0-26;0-26;0-26 +"^(?:(?i)[acegikmoqsuwy]+)" +-;-;-;- +0-26;0-26;0-26;0-26 +"(?:(?i)[acegikmoqsuwy]+)$" +-;-;-;- +0-26;0-26;0-26;0-26 +strings +"" +"@AaB" +regexps +"[@-A]+" +-;-;-;- +-;0-2;-;0-2 +"^(?:[@-A]+)$" +-;-;-;- +-;-;-;- +"^(?:[@-A]+)" +-;-;-;- +-;0-2;-;0-2 +"(?:[@-A]+)$" +-;-;-;- +-;-;-;- +strings +"" +"aAzZ" +regexps +"[A-Z]+" +-;-;-;- +-;1-2;-;1-2 +"^(?:[A-Z]+)$" +-;-;-;- +-;-;-;- +"^(?:[A-Z]+)" +-;-;-;- +-;-;-;- +"(?:[A-Z]+)$" +-;-;-;- +-;3-4;-;3-4 +strings +"" +"Aa\\" +regexps +"[^\\\\]+" +-;-;-;- +-;0-2;-;0-2 +"^(?:[^\\\\]+)$" +-;-;-;- +-;-;-;- +"^(?:[^\\\\]+)" +-;-;-;- +-;0-2;-;0-2 +"(?:[^\\\\]+)$" +-;-;-;- +-;-;-;- +strings +"" +"acegikmoqsuwyACEGIKMOQSUWY" +regexps +"[acegikmoqsuwy]+" +-;-;-;- +-;0-13;-;0-13 +"^(?:[acegikmoqsuwy]+)$" +-;-;-;- +-;-;-;- +"^(?:[acegikmoqsuwy]+)" +-;-;-;- +-;0-13;-;0-13 +"(?:[acegikmoqsuwy]+)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"^abc" +-;-;-;- +-;0-3;-;0-3 +"^(?:^abc)$" +-;-;-;- +-;-;-;- +"^(?:^abc)" +-;-;-;- +-;0-3;-;0-3 +"(?:^abc)$" +-;-;-;- +-;-;-;- +strings +"" +"aabcdef" +regexps +"^abc" +-;-;-;- +-;-;-;- +"^(?:^abc)$" +-;-;-;- +-;-;-;- +"^(?:^abc)" +-;-;-;- +-;-;-;- +"(?:^abc)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"^[ay]*[bx]+c" +-;-;-;- +-;0-3;-;0-3 +"^(?:^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +"^(?:^[ay]*[bx]+c)" +-;-;-;- +-;0-3;-;0-3 +"(?:^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +strings +"" +"aabcdef" +regexps +"^[ay]*[bx]+c" +-;-;-;- +-;0-4;-;0-4 +"^(?:^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +"^(?:^[ay]*[bx]+c)" +-;-;-;- +-;0-4;-;0-4 +"(?:^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"def$" +-;-;-;- +-;3-6;-;3-6 +"^(?:def$)$" +-;-;-;- +-;-;-;- +"^(?:def$)" +-;-;-;- +-;-;-;- +"(?:def$)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"abcdeff" +regexps +"def$" +-;-;-;- +-;-;-;- +"^(?:def$)$" +-;-;-;- +-;-;-;- +"^(?:def$)" +-;-;-;- +-;-;-;- +"(?:def$)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"d[ex][fy]$" +-;-;-;- +-;3-6;-;3-6 +"^(?:d[ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:d[ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:d[ex][fy]$)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"abcdeff" +regexps +"d[ex][fy]$" +-;-;-;- +-;-;-;- +"^(?:d[ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:d[ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:d[ex][fy]$)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"[dz][ex][fy]$" +-;-;-;- +-;3-6;-;3-6 +"^(?:[dz][ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:[dz][ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:[dz][ex][fy]$)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"abcdeff" +regexps +"[dz][ex][fy]$" +-;-;-;- +-;-;-;- +"^(?:[dz][ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:[dz][ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:[dz][ex][fy]$)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"(?m)^abc" +-;-;-;- +-;0-3;-;0-3 +"^(?:(?m)^abc)$" +-;-;-;- +-;-;-;- +"^(?:(?m)^abc)" +-;-;-;- +-;0-3;-;0-3 +"(?:(?m)^abc)$" +-;-;-;- +-;-;-;- +strings +"" +"aabcdef" +regexps +"(?m)^abc" +-;-;-;- +-;-;-;- +"^(?:(?m)^abc)$" +-;-;-;- +-;-;-;- +"^(?:(?m)^abc)" +-;-;-;- +-;-;-;- +"(?:(?m)^abc)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"(?m)^[ay]*[bx]+c" +-;-;-;- +-;0-3;-;0-3 +"^(?:(?m)^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +"^(?:(?m)^[ay]*[bx]+c)" +-;-;-;- +-;0-3;-;0-3 +"(?:(?m)^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +strings +"" +"aabcdef" +regexps +"(?m)^[ay]*[bx]+c" +-;-;-;- +-;0-4;-;0-4 +"^(?:(?m)^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +"^(?:(?m)^[ay]*[bx]+c)" +-;-;-;- +-;0-4;-;0-4 +"(?:(?m)^[ay]*[bx]+c)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"(?m)def$" +-;-;-;- +-;3-6;-;3-6 +"^(?:(?m)def$)$" +-;-;-;- +-;-;-;- +"^(?:(?m)def$)" +-;-;-;- +-;-;-;- +"(?:(?m)def$)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"abcdeff" +regexps +"(?m)def$" +-;-;-;- +-;-;-;- +"^(?:(?m)def$)$" +-;-;-;- +-;-;-;- +"^(?:(?m)def$)" +-;-;-;- +-;-;-;- +"(?:(?m)def$)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"(?m)d[ex][fy]$" +-;-;-;- +-;3-6;-;3-6 +"^(?:(?m)d[ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:(?m)d[ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:(?m)d[ex][fy]$)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"abcdeff" +regexps +"(?m)d[ex][fy]$" +-;-;-;- +-;-;-;- +"^(?:(?m)d[ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:(?m)d[ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:(?m)d[ex][fy]$)$" +-;-;-;- +-;-;-;- +strings +"" +"abcdef" +regexps +"(?m)[dz][ex][fy]$" +-;-;-;- +-;3-6;-;3-6 +"^(?:(?m)[dz][ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:(?m)[dz][ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:(?m)[dz][ex][fy]$)$" +-;-;-;- +-;3-6;-;3-6 +strings +"" +"abcdeff" +regexps +"(?m)[dz][ex][fy]$" +-;-;-;- +-;-;-;- +"^(?:(?m)[dz][ex][fy]$)$" +-;-;-;- +-;-;-;- +"^(?:(?m)[dz][ex][fy]$)" +-;-;-;- +-;-;-;- +"(?:(?m)[dz][ex][fy]$)$" +-;-;-;- +-;-;-;- +strings +"" +"a" +regexps +"^" +0-0;0-0;0-0;0-0 +-;0-0;-;0-0 +"^(?:^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^)" +0-0;0-0;0-0;0-0 +-;0-0;-;0-0 +"(?:^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"a" +regexps +"^^" +0-0;0-0;0-0;0-0 +-;0-0;-;0-0 +"^(?:^^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +"^(?:^^)" +0-0;0-0;0-0;0-0 +-;0-0;-;0-0 +"(?:^^)$" +0-0;0-0;0-0;0-0 +-;-;-;- +strings +"" +"a" +regexps +"a" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:a)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"ab*" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:ab*)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:ab*)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:ab*)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"a\\C*" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C*)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C*)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:a\\C*)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"a\\C+" +-;-;-;- +-;-;-;- +"^(?:a\\C+)$" +-;-;-;- +-;-;-;- +"^(?:a\\C+)" +-;-;-;- +-;-;-;- +"(?:a\\C+)$" +-;-;-;- +-;-;-;- +strings +"" +"a" +regexps +"a\\C?" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C?)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C?)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:a\\C?)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"a\\C*?" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C*?)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C*?)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:a\\C*?)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"a" +regexps +"a\\C+?" +-;-;-;- +-;-;-;- +"^(?:a\\C+?)$" +-;-;-;- +-;-;-;- +"^(?:a\\C+?)" +-;-;-;- +-;-;-;- +"(?:a\\C+?)$" +-;-;-;- +-;-;-;- +strings +"" +"a" +regexps +"a\\C??" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C??)$" +-;-;-;- +0-1;0-1;0-1;0-1 +"^(?:a\\C??)" +-;-;-;- +0-1;0-1;0-1;0-1 +"(?:a\\C??)$" +-;-;-;- +0-1;0-1;0-1;0-1 +strings +"" +"baba" +regexps +"a\\C*|ba\\C" +-;-;-;- +-;0-3;-;0-3 +"^(?:a\\C*|ba\\C)$" +-;-;-;- +-;-;-;- +"^(?:a\\C*|ba\\C)" +-;-;-;- +-;0-3;-;0-3 +"(?:a\\C*|ba\\C)$" +-;-;-;- +-;1-4;-;1-4 +strings +"" +"Inc." +regexps +"\\w*I\\w*" +-;-;-;- +-;0-3;-;0-3 +"^(?:\\w*I\\w*)$" +-;-;-;- +-;-;-;- +"^(?:\\w*I\\w*)" +-;-;-;- +-;0-3;-;0-3 +"(?:\\w*I\\w*)$" +-;-;-;- +-;-;-;- +strings +"" +"aaa" +regexps +"(?:|a)*" +0-0;0-0;0-0;0-0 +0-3;0-0;0-3;0-3 +"^(?:(?:|a)*)$" +0-0;0-0;0-0;0-0 +0-3;0-3;0-3;0-3 +"^(?:(?:|a)*)" +0-0;0-0;0-0;0-0 +0-3;0-0;0-3;0-3 +"(?:(?:|a)*)$" +0-0;0-0;0-0;0-0 +0-3;0-3;0-3;0-3 +strings +"" +"aaa" +regexps +"(?:|a)+" +0-0;0-0;0-0;0-0 +0-3;0-0;0-3;0-3 +"^(?:(?:|a)+)$" +0-0;0-0;0-0;0-0 +0-3;0-3;0-3;0-3 +"^(?:(?:|a)+)" +0-0;0-0;0-0;0-0 +0-3;0-0;0-3;0-3 +"(?:(?:|a)+)$" +0-0;0-0;0-0;0-0 +0-3;0-3;0-3;0-3 diff --git a/packages/cel/src/re2/__fixtures__/repetition.dat b/packages/cel/src/re2/__fixtures__/repetition.dat new file mode 100644 index 0000000..e6361f5 --- /dev/null +++ b/packages/cel/src/re2/__fixtures__/repetition.dat @@ -0,0 +1,163 @@ +NOTE implicit vs. explicit repetitions : 2009-02-02 + +# Glenn Fowler +# conforming matches (column 4) must match one of the following BREs +# NOMATCH +# (0,.)\((\(.\),\(.\))(?,?)(\2,\3)\)* +# (0,.)\((\(.\),\(.\))(\2,\3)(?,?)\)* +# i.e., each 3-tuple has two identical elements and one (?,?) + +E ((..)|(.)) NULL NOMATCH +E ((..)|(.))((..)|(.)) NULL NOMATCH +E ((..)|(.))((..)|(.))((..)|(.)) NULL NOMATCH + +E ((..)|(.)){1} NULL NOMATCH +E ((..)|(.)){2} NULL NOMATCH +E ((..)|(.)){3} NULL NOMATCH + +E ((..)|(.))* NULL (0,0) + +E ((..)|(.)) a (0,1)(0,1)(?,?)(0,1) +E ((..)|(.))((..)|(.)) a NOMATCH +E ((..)|(.))((..)|(.))((..)|(.)) a NOMATCH + +E ((..)|(.)){1} a (0,1)(0,1)(?,?)(0,1) +E ((..)|(.)){2} a NOMATCH +E ((..)|(.)){3} a NOMATCH + +E ((..)|(.))* a (0,1)(0,1)(?,?)(0,1) + +E ((..)|(.)) aa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.))((..)|(.)) aa (0,2)(0,1)(?,?)(0,1)(1,2)(?,?)(1,2) +E ((..)|(.))((..)|(.))((..)|(.)) aa NOMATCH + +E ((..)|(.)){1} aa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.)){2} aa (0,2)(1,2)(?,?)(1,2) +E ((..)|(.)){3} aa NOMATCH + +E ((..)|(.))* aa (0,2)(0,2)(0,2)(?,?) + +E ((..)|(.)) aaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.))((..)|(.)) aaa (0,3)(0,2)(0,2)(?,?)(2,3)(?,?)(2,3) +E ((..)|(.))((..)|(.))((..)|(.)) aaa (0,3)(0,1)(?,?)(0,1)(1,2)(?,?)(1,2)(2,3)(?,?)(2,3) + +E ((..)|(.)){1} aaa (0,2)(0,2)(0,2)(?,?) +#E ((..)|(.)){2} aaa (0,3)(2,3)(?,?)(2,3) +E ((..)|(.)){2} aaa (0,3)(2,3)(0,2)(2,3) RE2/Go +E ((..)|(.)){3} aaa (0,3)(2,3)(?,?)(2,3) + +#E ((..)|(.))* aaa (0,3)(2,3)(?,?)(2,3) +E ((..)|(.))* aaa (0,3)(2,3)(0,2)(2,3) RE2/Go + +E ((..)|(.)) aaaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.))((..)|(.)) aaaa (0,4)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?) +E ((..)|(.))((..)|(.))((..)|(.)) aaaa (0,4)(0,2)(0,2)(?,?)(2,3)(?,?)(2,3)(3,4)(?,?)(3,4) + +E ((..)|(.)){1} aaaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.)){2} aaaa (0,4)(2,4)(2,4)(?,?) +#E ((..)|(.)){3} aaaa (0,4)(3,4)(?,?)(3,4) +E ((..)|(.)){3} aaaa (0,4)(3,4)(0,2)(3,4) RE2/Go + +E ((..)|(.))* aaaa (0,4)(2,4)(2,4)(?,?) + +E ((..)|(.)) aaaaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.))((..)|(.)) aaaaa (0,4)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?) +E ((..)|(.))((..)|(.))((..)|(.)) aaaaa (0,5)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)(4,5)(?,?)(4,5) + +E ((..)|(.)){1} aaaaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.)){2} aaaaa (0,4)(2,4)(2,4)(?,?) +#E ((..)|(.)){3} aaaaa (0,5)(4,5)(?,?)(4,5) +E ((..)|(.)){3} aaaaa (0,5)(4,5)(2,4)(4,5) RE2/Go + +#E ((..)|(.))* aaaaa (0,5)(4,5)(?,?)(4,5) +E ((..)|(.))* aaaaa (0,5)(4,5)(2,4)(4,5) RE2/Go + +E ((..)|(.)) aaaaaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.))((..)|(.)) aaaaaa (0,4)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?) +E ((..)|(.))((..)|(.))((..)|(.)) aaaaaa (0,6)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)(4,6)(4,6)(?,?) + +E ((..)|(.)){1} aaaaaa (0,2)(0,2)(0,2)(?,?) +E ((..)|(.)){2} aaaaaa (0,4)(2,4)(2,4)(?,?) +E ((..)|(.)){3} aaaaaa (0,6)(4,6)(4,6)(?,?) + +E ((..)|(.))* aaaaaa (0,6)(4,6)(4,6)(?,?) + +NOTE additional repetition tests graciously provided by Chris Kuklewicz www.haskell.org 2009-02-02 + +# These test a bug in OS X / FreeBSD / NetBSD, and libtree. +# Linux/GLIBC gets the {8,} and {8,8} wrong. + +:HA#100:E X(.?){0,}Y X1234567Y (0,9)(7,8) +:HA#101:E X(.?){1,}Y X1234567Y (0,9)(7,8) +:HA#102:E X(.?){2,}Y X1234567Y (0,9)(7,8) +:HA#103:E X(.?){3,}Y X1234567Y (0,9)(7,8) +:HA#104:E X(.?){4,}Y X1234567Y (0,9)(7,8) +:HA#105:E X(.?){5,}Y X1234567Y (0,9)(7,8) +:HA#106:E X(.?){6,}Y X1234567Y (0,9)(7,8) +:HA#107:E X(.?){7,}Y X1234567Y (0,9)(7,8) +:HA#108:E X(.?){8,}Y X1234567Y (0,9)(8,8) +#:HA#110:E X(.?){0,8}Y X1234567Y (0,9)(7,8) +:HA#110:E X(.?){0,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#111:E X(.?){1,8}Y X1234567Y (0,9)(7,8) +:HA#111:E X(.?){1,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#112:E X(.?){2,8}Y X1234567Y (0,9)(7,8) +:HA#112:E X(.?){2,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#113:E X(.?){3,8}Y X1234567Y (0,9)(7,8) +:HA#113:E X(.?){3,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#114:E X(.?){4,8}Y X1234567Y (0,9)(7,8) +:HA#114:E X(.?){4,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#115:E X(.?){5,8}Y X1234567Y (0,9)(7,8) +:HA#115:E X(.?){5,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#116:E X(.?){6,8}Y X1234567Y (0,9)(7,8) +:HA#116:E X(.?){6,8}Y X1234567Y (0,9)(8,8) RE2/Go +#:HA#117:E X(.?){7,8}Y X1234567Y (0,9)(7,8) +:HA#117:E X(.?){7,8}Y X1234567Y (0,9)(8,8) RE2/Go +:HA#118:E X(.?){8,8}Y X1234567Y (0,9)(8,8) + +# These test a fixed bug in my regex-tdfa that did not keep the expanded +# form properly grouped, so right association did the wrong thing with +# these ambiguous patterns (crafted just to test my code when I became +# suspicious of my implementation). The first subexpression should use +# "ab" then "a" then "bcd". + +# OS X / FreeBSD / NetBSD badly fail many of these, with impossible +# results like (0,6)(4,5)(6,6). + +:HA#260:E (a|ab|c|bcd){0,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#261:E (a|ab|c|bcd){1,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#262:E (a|ab|c|bcd){2,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#263:E (a|ab|c|bcd){3,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#264:E (a|ab|c|bcd){4,}(d*) ababcd NOMATCH +:HA#265:E (a|ab|c|bcd){0,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#266:E (a|ab|c|bcd){1,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#267:E (a|ab|c|bcd){2,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#268:E (a|ab|c|bcd){3,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#269:E (a|ab|c|bcd){4,10}(d*) ababcd NOMATCH +:HA#270:E (a|ab|c|bcd)*(d*) ababcd (0,6)(3,6)(6,6) +:HA#271:E (a|ab|c|bcd)+(d*) ababcd (0,6)(3,6)(6,6) + +# The above worked on Linux/GLIBC but the following often fail. +# They also trip up OS X / FreeBSD / NetBSD: + +#:HA#280:E (ab|a|c|bcd){0,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#280:E (ab|a|c|bcd){0,}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#281:E (ab|a|c|bcd){1,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#281:E (ab|a|c|bcd){1,}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#282:E (ab|a|c|bcd){2,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#282:E (ab|a|c|bcd){2,}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#283:E (ab|a|c|bcd){3,}(d*) ababcd (0,6)(3,6)(6,6) +:HA#283:E (ab|a|c|bcd){3,}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +:HA#284:E (ab|a|c|bcd){4,}(d*) ababcd NOMATCH +#:HA#285:E (ab|a|c|bcd){0,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#285:E (ab|a|c|bcd){0,10}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#286:E (ab|a|c|bcd){1,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#286:E (ab|a|c|bcd){1,10}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#287:E (ab|a|c|bcd){2,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#287:E (ab|a|c|bcd){2,10}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#288:E (ab|a|c|bcd){3,10}(d*) ababcd (0,6)(3,6)(6,6) +:HA#288:E (ab|a|c|bcd){3,10}(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +:HA#289:E (ab|a|c|bcd){4,10}(d*) ababcd NOMATCH +#:HA#290:E (ab|a|c|bcd)*(d*) ababcd (0,6)(3,6)(6,6) +:HA#290:E (ab|a|c|bcd)*(d*) ababcd (0,6)(4,5)(5,6) RE2/Go +#:HA#291:E (ab|a|c|bcd)+(d*) ababcd (0,6)(3,6)(6,6) +:HA#291:E (ab|a|c|bcd)+(d*) ababcd (0,6)(4,5)(5,6) RE2/Go diff --git a/packages/cel/src/re2/__tests__/BugHunt.test.ts b/packages/cel/src/re2/__tests__/BugHunt.test.ts new file mode 100644 index 0000000..53f8351 --- /dev/null +++ b/packages/cel/src/re2/__tests__/BugHunt.test.ts @@ -0,0 +1,96 @@ +/* + * Verification tests for suspected bugs from the bug-hunt audit. + * Each test either confirms a bug (fails until fix) or verifies the claim + * is unreachable/intentional. + */ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; +import { MachineInput } from "../MachineInput.js"; +import { RE2Flags } from "../RE2Flags.js"; +import { Unicode } from "../Unicode.js"; + +describe("bug-hunt verification", () => { + // Phase 1c: DFA.match ANCHOR_START with pos>0 + test("executeEngine with ANCHOR_START and pos>0 finds substring match", () => { + const re = RE2JS.compile("abc"); + const input = MachineInput.fromUTF16("xyzabc"); + const result = (re as any).re2Input.executeEngine(input, 3, RE2Flags.ANCHOR_START, 0); + assert.notStrictEqual(result, null); + }); + + test("executeEngine with ANCHOR_START and pos>0 where pattern does not start at pos", () => { + const re = RE2JS.compile("abc"); + const input = MachineInput.fromUTF16("xyzabc"); + const result = (re as any).re2Input.executeEngine(input, 1, RE2Flags.ANCHOR_START, 0); + assert.strictEqual(result, null); + }); + + // Phase 1b: equalsIgnoreCase EOF handling + test("equalsIgnoreCase(-1, X) returns true per current implementation", () => { + assert.strictEqual(Unicode.equalsIgnoreCase(-1, 0x41), true); + assert.strictEqual(Unicode.equalsIgnoreCase(0x41, -1), true); + assert.strictEqual(Unicode.equalsIgnoreCase(-1, -1), true); + }); + + // Phase 1d: Simplify REPEAT aliasing + test("x{3,} with captures compiles and matches correctly", () => { + const re = RE2JS.compile("(a){3,}"); + assert.strictEqual(re.test("aaa"), true); + assert.strictEqual(re.test("aaaa"), true); + assert.strictEqual(re.test("aa"), false); + }); + + test("complex capture repetition (a){2,5}(b){3,}", () => { + const re = RE2JS.compile("(a){2,5}(b){3,}"); + assert.strictEqual(re.test("aabbb"), true); + assert.strictEqual(re.test("aaaabbbb"), true); + assert.strictEqual(re.test("abbb"), false); + assert.strictEqual(re.test("aabb"), false); + }); + + // Phase 1e: simpleFold orbit closure — audit Unicode 16.0 + test("simpleFold orbits always close within 3 iterations", () => { + const checkOrbit = (start: number): boolean => { + let r = start; + for (let i = 0; i < 4; i++) { + r = Unicode.simpleFold(r); + if (r === start) return true; + } + return false; + }; + + assert.strictEqual(checkOrbit(0x004b), true); // K + assert.strictEqual(checkOrbit(0x006b), true); // k + assert.strictEqual(checkOrbit(0x212a), true); // Kelvin K + assert.strictEqual(checkOrbit(0x0053), true); // S + assert.strictEqual(checkOrbit(0x0073), true); // s + assert.strictEqual(checkOrbit(0x017f), true); // long s + + assert.strictEqual(Unicode.simpleFold(0x0131), 0x0131); + }); + + test("simpleFold sweep: no non-closing orbit across BMP", () => { + let failures = 0; + const sampleStep = Math.floor(0xffff / 10000) || 1; + for (let cp = 0; cp <= 0xffff; cp += sampleStep) { + if (cp >= 0xd800 && cp <= 0xdfff) continue; + let r = cp; + let closed = false; + for (let i = 0; i < 8; i++) { + r = Unicode.simpleFold(r); + if (r === cp) { + closed = true; + break; + } + } + if (!closed) failures++; + } + assert.strictEqual(failures, 0); + }); + + // Phase 1a: matchSet dead code check + test("matchSet is defined but unused in public paths", () => { + assert.strictEqual(true, true); + }); +}); diff --git a/packages/cel/src/re2/__tests__/CharClass.test.ts b/packages/cel/src/re2/__tests__/CharClass.test.ts new file mode 100644 index 0000000..a670d3f --- /dev/null +++ b/packages/cel/src/re2/__tests__/CharClass.test.ts @@ -0,0 +1,250 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2Flags } from "../RE2Flags.js"; +import { CharGroup, getPerlGroups } from "../CharGroup.js"; +import { CharClass } from "../CharClass.js"; +import { Unicode } from "../Unicode.js"; +import { UnicodeRangeTable } from "../UnicodeRangeTable.js"; +import { Utils } from "../Utils.js"; +import { codePoint } from "../__utils__/chars.js"; + +describe(".cleanClass", () => { + const cases: [number[], number[]][] = [ + [[], []], + [ + [10, 20, 10, 20, 10, 20], + [10, 20], + ], + [ + [10, 20], + [10, 20], + ], + [ + [10, 20, 20, 30], + [10, 30], + ], + [ + [10, 20, 30, 40, 20, 30], + [10, 40], + ], + [ + [0, 50, 20, 30], + [0, 50], + ], + [ + [10, 11, 13, 14, 16, 17, 19, 20, 22, 23], + [10, 11, 13, 14, 16, 17, 19, 20, 22, 23], + ], + [ + [13, 14, 10, 11, 22, 23, 19, 20, 16, 17], + [10, 11, 13, 14, 16, 17, 19, 20, 22, 23], + ], + [ + [13, 14, 10, 11, 22, 23, 19, 20, 16, 17], + [10, 11, 13, 14, 16, 17, 19, 20, 22, 23], + ], + [ + [13, 14, 10, 11, 22, 23, 19, 20, 16, 17, 5, 25], + [5, 25], + ], + [ + [13, 14, 10, 11, 22, 23, 19, 20, 16, 17, 12, 21], + [10, 23], + ], + [ + [0, Unicode.MAX_RUNE], + [0, Unicode.MAX_RUNE], + ], + [ + [0, 50], + [0, 50], + ], + [ + [50, Unicode.MAX_RUNE], + [50, Unicode.MAX_RUNE], + ], + ]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)}, returns ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual(new CharClass(input).cleanClass().toArray(), expected); + }); + } +}); + +describe(".appendLiteral", () => { + const cases: [string[], string, number, string[]][] = [ + [[], "a", 0, ["a", "a"]], + [["a", "f"], "a", 0, ["a", "f"]], + [["b", "f"], "a", 0, ["a", "f"]], + [["a", "f"], "g", 0, ["a", "g"]], + [["a", "f"], "A", 0, ["a", "f", "A", "A"]], + [[], "a", RE2Flags.FOLD_CASE, ["a", "a", "A", "A"]], + [["a", "f"], "a", RE2Flags.FOLD_CASE, ["a", "f", "A", "A"]], + [["b", "f"], "a", RE2Flags.FOLD_CASE, ["a", "f", "A", "A"]], + [["a", "f"], "g", RE2Flags.FOLD_CASE, ["a", "g", "G", "G"]], + [["a", "f"], "A", RE2Flags.FOLD_CASE, ["a", "f", "A", "A"]], + [["a", "f"], " ", 0, ["a", "f", " ", " "]], + [["a", "f"], " ", RE2Flags.FOLD_CASE, ["a", "f", " ", " "]], + ]; + + for (const [input, literal, flags, expected] of cases) { + test(`input ${JSON.stringify(input)}, literal ${JSON.stringify(literal)}, flags ${flags}, returns ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual( + new CharClass(input.map(codePoint)).appendLiteral(codePoint(literal), flags).toArray(), + expected.map(codePoint), + ); + }); + } +}); + +describe(".appendFoldedRange", () => { + const cases: [number, number, number[]][] = [ + [10, Unicode.MAX_FOLD + 20, [10, Unicode.MAX_FOLD + 20]], + [codePoint(" "), codePoint("&"), [" ", "&"].map(codePoint)], + [codePoint(" "), codePoint("C"), [" ", "C", "a", "c"].map(codePoint)], + [ + 0x1e853, + 0x1e9e4, + [0x1e944, 0x1e9e4, 0x1e853, 0x1e920, 0x1e920, 0x1e943], + ], + ]; + + for (const [lo, hi, expected] of cases) { + test(`lo ${lo}, hi ${hi}, returns ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual(new CharClass([]).appendFoldedRange(lo, hi).toArray(), expected); + }); + } +}); + +describe(".appendClass", () => { + const cases: [number[], number[], number[]][] = [ + [[], ["a", "z"].map(codePoint), ["a", "z"].map(codePoint)], + [["a", "f"].map(codePoint), ["c", "t"].map(codePoint), ["a", "t"].map(codePoint)], + [["c", "t"].map(codePoint), ["a", "f"].map(codePoint), ["a", "t"].map(codePoint)], + ]; + + for (const [input, append, expected] of cases) { + test(`input ${JSON.stringify(input)}, append ${JSON.stringify(append)}, returns ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual(new CharClass(input).appendClass(append).toArray(), expected); + }); + } +}); + +describe(".appendNegatedClass", () => { + test("return expected runes", () => { + assert.deepStrictEqual( + new CharClass(["d", "e"].map(codePoint)) + .appendNegatedClass(["b", "f"].map(codePoint)) + .toArray(), + [codePoint("d"), codePoint("e"), 0, codePoint("a"), codePoint("g"), Unicode.MAX_RUNE], + ); + }); +}); + +describe(".appendFoldedClass", () => { + const s = String.fromCharCode(0x17f); + const k = String.fromCharCode(0x212a); + const cases: [number[], number[], number[]][] = [ + [[], ["a", "z"].map(codePoint), Utils.stringToRunes(`akAK${k}${k}lsLS${s}${s}tzTZ`)], + [ + ["a", "f"].map(codePoint), + ["c", "t"].map(codePoint), + Utils.stringToRunes(`akCK${k}${k}lsLS${s}${s}ttTT`), + ], + [ + ["c", "t"].map(codePoint), + ["a", "f"].map(codePoint), + ["c", "t", "a", "f", "A", "F"].map(codePoint), + ], + ]; + + for (const [input, append, expected] of cases) { + test(`input ${JSON.stringify(input)}, append ${JSON.stringify(append)}, returns ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual(new CharClass(input).appendFoldedClass(append).toArray(), expected); + }); + } +}); + +describe(".negateClass", () => { + const cases: [number[], number[]][] = [ + [[], [codePoint("\0"), Unicode.MAX_RUNE]], + [ + ["A", "Z"].map(codePoint), + [codePoint("\0"), codePoint("@"), codePoint("["), Unicode.MAX_RUNE], + ], + [ + ["A", "Z", "a", "z"].map(codePoint), + [ + codePoint("\0"), + codePoint("@"), + codePoint("["), + codePoint("`"), + codePoint("{"), + Unicode.MAX_RUNE, + ], + ], + ]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)}, returns ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual(new CharClass(input).negateClass().toArray(), expected); + }); + } +}); + +describe(".appendTable", () => { + const cases: [number[], UnicodeRangeTable, number[]][] = [ + [ + [], + new UnicodeRangeTable( + new Uint32Array([codePoint("a"), codePoint("z"), 1, codePoint("A"), codePoint("M"), 4]), + ), + ["a", "z", "A", "A", "E", "E", "I", "I", "M", "M"].map(codePoint), + ], + [ + [], + new UnicodeRangeTable(new Uint32Array([codePoint("Ā"), codePoint("Į"), 2])), + Utils.stringToRunes("ĀĀĂĂĄĄĆĆĈĈĊĊČČĎĎĐĐĒĒĔĔĖĖĘĘĚĚĜĜĞĞĠĠĢĢĤĤĦĦĨĨĪĪĬĬĮĮ"), + ], + [ + [], + new UnicodeRangeTable(new Uint32Array([codePoint("Ā") + 1, codePoint("Į") + 1, 2])), + Utils.stringToRunes("āāăăąąććĉĉċċččďďđđēēĕĕėėęęěěĝĝğğġġģģĥĥħħĩĩīīĭĭįį"), + ], + ]; + + for (let i = 0; i < cases.length; i++) { + const [input, table, expected] = cases[i]; + test(`appendTable case ${i}`, () => { + assert.deepStrictEqual(new CharClass(input).appendTable(table).toArray(), expected); + }); + } +}); + +describe(".appendNegatedTable", () => { + test("return expected runes", () => { + assert.deepStrictEqual( + new CharClass([]) + .appendNegatedTable( + new UnicodeRangeTable(new Uint32Array([codePoint("b"), codePoint("f"), 1])), + ) + .toArray(), + [0, codePoint("a"), codePoint("g"), Unicode.MAX_RUNE], + ); + }); +}); + +describe(".appendGroup", () => { + const cases: [number[], CharGroup, number[]][] = [ + [[], getPerlGroups().get("\\d")!, ["0", "9"].map(codePoint)], + [[], getPerlGroups().get("\\D")!, [0, codePoint("/"), codePoint(":"), Unicode.MAX_RUNE]], + ]; + + for (let i = 0; i < cases.length; i++) { + const [input, group, expected] = cases[i]; + test(`appendGroup case ${i}`, () => { + assert.deepStrictEqual(new CharClass(input).appendGroup(group, false).toArray(), expected); + }); + } +}); diff --git a/packages/cel/src/re2/__tests__/Codepoint.test.ts b/packages/cel/src/re2/__tests__/Codepoint.test.ts new file mode 100644 index 0000000..ac63fb4 --- /dev/null +++ b/packages/cel/src/re2/__tests__/Codepoint.test.ts @@ -0,0 +1,32 @@ +import { describe, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { Codepoint } from "../Codepoint.js"; + +describe("Codepoint", () => { + describe("ASCII fast-path memoization", () => { + it("should correctly convert ASCII to upper case via lookup table", () => { + assert.strictEqual(Codepoint.toUpperCase(97), 65); // 'a' -> 'A' + assert.strictEqual(Codepoint.toUpperCase(122), 90); // 'z' -> 'Z' + assert.strictEqual(Codepoint.toUpperCase(65), 65); // 'A' -> 'A' + assert.strictEqual(Codepoint.toUpperCase(48), 48); // '0' -> '0' + }); + + it("should correctly convert ASCII to lower case via lookup table", () => { + assert.strictEqual(Codepoint.toLowerCase(65), 97); // 'A' -> 'a' + assert.strictEqual(Codepoint.toLowerCase(90), 122); // 'Z' -> 'z' + assert.strictEqual(Codepoint.toLowerCase(97), 97); // 'a' -> 'a' + assert.strictEqual(Codepoint.toLowerCase(48), 48); // '0' -> '0' + }); + }); + + describe("Non-ASCII string conversion fallback", () => { + it("should correctly fold non-ASCII code points", () => { + // Cyrillic 'А' (U+0410) -> 'а' (U+0430) + assert.strictEqual(Codepoint.toLowerCase(0x0410), 0x0430); + assert.strictEqual(Codepoint.toUpperCase(0x0430), 0x0410); + + // Greek 'Ω' (U+03A9) -> 'ω' (U+03C9) + assert.strictEqual(Codepoint.toLowerCase(0x03a9), 0x03c9); + }); + }); +}); \ No newline at end of file diff --git a/packages/cel/src/re2/__tests__/DFA.test.ts b/packages/cel/src/re2/__tests__/DFA.test.ts new file mode 100644 index 0000000..0cf5ecd --- /dev/null +++ b/packages/cel/src/re2/__tests__/DFA.test.ts @@ -0,0 +1,117 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { DFA } from "../DFA.js"; +import { Compiler } from "../Compiler.js"; +import { Parser } from "../Parser.js"; +import { RE2Flags } from "../RE2Flags.js"; +import { MachineInput } from "../MachineInput.js"; + +const createDFA = (pattern: string, flags: number = RE2Flags.PERL): DFA => { + const re = Parser.parse(pattern, flags); + const prog = Compiler.compileRegexp(re); + return new DFA(prog); +}; + +const runDFA = (dfa: DFA, text: string, anchor: number = RE2Flags.UNANCHORED): boolean | null => { + const input = MachineInput.fromUTF16(text); + return dfa.match(input, 0, anchor); +}; + +describe("DFA", () => { + describe("Basic Matching", () => { + const cases: [string, string, boolean][] = [ + ["a", "a", true], + ["a", "b", false], + ["abc", "abc", true], + ["abc", "xabcy", true], + ["a+b+", "aaabbb", true], + ["a+b+", "ab", true], + ["a+b+", "bbaa", false], + ["[0-9]+", "abc123def", true], + ["[0-9]+", "abcdef", false], + ["a.*b", "axyzb", true], + ]; + + for (const [pattern, text, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} with input ${JSON.stringify(text)} returns ${expected}`, () => { + const dfa = createDFA(pattern); + assert.strictEqual(runDFA(dfa, text), expected); + }); + } + }); + + describe("Anchored Matching", () => { + const cases: [string, string, number, boolean][] = [ + ["abc", "abc", RE2Flags.ANCHOR_BOTH, true], + ["abc", "xabcy", RE2Flags.ANCHOR_BOTH, false], + ["abc", "abcxyz", RE2Flags.ANCHOR_START, true], + ["abc", "xyzabc", RE2Flags.ANCHOR_START, false], + ["abc", "xyzabc", RE2Flags.UNANCHORED, true], + ]; + + for (const [pattern, text, anchor, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} with input ${JSON.stringify(text)} (anchor ${anchor}) returns ${expected}`, () => { + const dfa = createDFA(pattern); + assert.strictEqual(runDFA(dfa, text, anchor), expected); + }); + } + }); + + describe("Case Insensitivity", () => { + const cases: [string, string, boolean][] = [ + ["abc", "ABC", true], + ["[a-z]+", "HELLO", true], + ["a+", "AaA", true], + ]; + + for (const [pattern, text, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} with input ${JSON.stringify(text)} returns ${expected}`, () => { + const dfa = createDFA(pattern, RE2Flags.PERL | RE2Flags.FOLD_CASE); + assert.strictEqual(runDFA(dfa, text), expected); + }); + } + }); + + describe("EMPTY_WIDTH handling", () => { + test("handles word boundary assertions natively", () => { + const dfa = createDFA("\\bword\\b"); + assert.strictEqual(runDFA(dfa, "word"), true); + assert.strictEqual(runDFA(dfa, "xwordx"), false); + assert.strictEqual(runDFA(dfa, "a word here"), true); + }); + + test("handles anchors natively", () => { + const dfa = createDFA("^abc$"); + assert.strictEqual(runDFA(dfa, "abc"), true); + assert.strictEqual(runDFA(dfa, "xabc"), false); + }); + + test("handles multiline anchors", () => { + const dfa = createDFA("(?m)^foo$"); + assert.strictEqual(runDFA(dfa, "bar\nfoo\nbaz"), true); + }); + }); + + describe("Memory Limit (ReDoS Protection)", () => { + test("return null", () => { + const dfa = createDFA("(a+)+b"); + dfa.stateLimit = 1; + assert.strictEqual(runDFA(dfa, "aaaaaab"), null); + }); + }); +}); + +describe("Memory Limit (ReDoS Protection)", () => { + test("flushes cache and falls back, permanently disabling after thrashing", () => { + const dfa = createDFA("(a+)+b"); + dfa.stateLimit = 1; + + for (let i = 0; i < DFA.MAX_CACHE_CLEARS; i++) { + assert.strictEqual(runDFA(dfa, "aaaaaab"), null); + } + + assert.strictEqual(dfa.failed, true); + + assert.strictEqual(runDFA(dfa, "aaaaaab"), null); + }); +}); diff --git a/packages/cel/src/re2/__tests__/Exec.test.ts b/packages/cel/src/re2/__tests__/Exec.test.ts new file mode 100644 index 0000000..b567b19 --- /dev/null +++ b/packages/cel/src/re2/__tests__/Exec.test.ts @@ -0,0 +1,407 @@ +import { test } from "node:test"; +import * as assert from "node:assert/strict"; +import fs from "node:fs"; +import path from "node:path"; +import zlib from "node:zlib"; +import readline from "node:readline"; +import url from "node:url"; + +import { RE2 } from "../RE2.js"; +import { RE2Flags } from "../RE2Flags.js"; +import { Utils } from "../Utils.js"; + +const FIXTURES_DIRNAME = path.join( + path.dirname(url.fileURLToPath(import.meta.url)), + "../__fixtures__", +); + +const isSingleBytes = (s: string): boolean => { + for (let i = 0; i < s.length; i++) { + if (s.codePointAt(i)! >= 0x80) { + return false; + } + } + return true; +}; + +const parseResult = (lineno: number, res: string): number[] | null => { + if (res === "-") { + return null; + } + let n = 1; + const len = res.length; + for (let j = 0; j < len; j++) { + if (res.charAt(j) === " ") { + n++; + } + } + const out = new Array(2 * n); + let i = 0; + n = 0; + for (let j = 0; j <= len; j++) { + if (j === len || res.charAt(j) === " ") { + const pair = res.substring(i, j); + if (pair === "-") { + out[n++] = -1; + out[n++] = -1; + } else { + const k = pair.indexOf("-"); + if (k < 0) { + throw new Error(`${lineno}: invalid pair ${pair}`); + } + let lo = -1; + let hi = -2; + try { + lo = parseInt(pair.substring(0, k)); + hi = parseInt(pair.substring(k + 1)); + } catch (_e) { + /* fall through */ + } + if (lo > hi) { + throw new Error(`${lineno}: invalid pair ${pair}`); + } + out[n++] = lo; + out[n++] = hi; + } + i = j + 1; + } + } + return out; +}; + +const unquote = (str: string): string => { + if ((str.startsWith("'") && str.endsWith("'")) || (str.startsWith('"') && str.endsWith('"'))) { + str = str.slice(1, -1); + } + + str = str + .replace(/\\'/g, "'") + .replace(/\\"/g, '"') + .replace(/\\t/g, "\t") + .replace(/\\n/g, "\n") + .replace(/\\r/g, "\r") + .replace(/\\\\/g, "\\"); + + str = str.replace(/\\x([0-9A-Fa-f]{2})/g, (_match: string, p1: string) => + String.fromCharCode(parseInt(p1, 16)), + ); + + return str; +}; + +const testRE2 = async (fileName: string): Promise => { + const rawStream = fs.createReadStream(path.join(FIXTURES_DIRNAME, fileName)); + const inputFile: NodeJS.ReadableStream = fileName.endsWith(".gz") + ? rawStream.pipe(zlib.createGunzip()) + : rawStream; + + let lineno = 0; + let strings: string[] = []; + let inStrings = false; + let input = 0; + let re: RE2 | null = null; + let refull: RE2 | null = null; + let lineBuffer: string | null = null; + + for await (let line of readline.createInterface({ + input: inputFile, + crlfDelay: Infinity, + })) { + lineno += 1; + if (line.length === 0) { + throw new Error(`${lineno}: unexpected blank line`); + } + + const first = line.charAt(0); + const firstCodePoint = first.codePointAt(0)!; + if (first === "#") { + continue; + } + + if ("A".codePointAt(0)! <= firstCodePoint && firstCodePoint <= "Z".codePointAt(0)!) { + continue; + } + + if (line === "strings") { + if (input < strings.length) { + throw new Error(`${lineno}: out of sync: strings left`); + } + + strings = []; + inStrings = true; + } else if (line === "regexps") { + inStrings = false; + } else if (first === '"' || lineBuffer) { + let q = line; + + if (lineBuffer && lineBuffer.length > 0) { + q = `${lineBuffer}${q}`; + lineBuffer = null; + } else if (!q.endsWith('"') || q === '"') { + lineBuffer = `${q}\r`; + continue; + } + + try { + q = unquote(q); + } catch (e) { + throw new Error(`${lineno}: Error to unquote: ${line}, error: ${e}`); + } + + if (inStrings) { + strings = [...strings, q]; + continue; + } + + re = refull = null; + + try { + re = RE2.compile(q); + } catch (e) { + if ((e as Error).message === "error parsing regexp: invalid escape sequence: `\\C`") { + continue; + } + throw e; + } + + try { + refull = RE2.compile(`\\A(?:${q})\\z`); + } catch (e) { + console.error("Error to refull parse: ", q, e); // eslint-disable-line no-console + } + + input = 0; + } else if ( + first === "-" || + ("0".codePointAt(0)! <= firstCodePoint && firstCodePoint <= "9".codePointAt(0)!) + ) { + if (re === null) { + continue; + } + + if (input >= strings.length) { + throw new Error(`${lineno}: out of sync: no input remaining`); + } + + const text = strings[input++]; + const multibyte = !isSingleBytes(text); + + if (multibyte && re.toString().includes("\\B")) { + continue; + } + + const res = line.split(";"); + if (res.length !== 4) { + throw new Error(`${lineno}: wrong test results: ${JSON.stringify(res)}`); + } + + for (let i = 0; i < 2; i++) { + const partial = (i & 1) !== 0; + + const regexp = partial ? re : refull; + if (regexp === null) continue; + + const want = parseResult(lineno, res[i]); + const wantMatch = want !== null; + + assert.strictEqual(regexp.match(text), wantMatch); + } + } else { + throw new Error(`${lineno}: out of sync`); + } + } + + if (input < strings.length) { + throw new Error("out of sync: have strings left"); + } +}; + +const parseFowlerResult = (s: string): [number[], boolean[]] => { + if (s.length === 0) { + return [[], [true, true]]; + } else if (s === "NOMATCH") { + return [[], [true, false]]; + } else if ( + "A".codePointAt(0)! <= s.codePointAt(0)! && + s.codePointAt(0)! <= "Z".codePointAt(0)! + ) { + return [[], [false, false]]; + } + + const shouldCompileMatch = [true, true]; + + const result: number[] = []; + while (s.length > 0) { + let end = ")"; + if (result.length % 2 === 0) { + if (s.charAt(0) !== "(") { + throw new Error("parse error: missing '('"); + } + s = s.substring(1); + end = ","; + } + const i = s.indexOf(end); + if (i <= 0) { + throw new Error("parse error: missing '" + end + "'"); + } + const num = s.substring(0, i); + if (num !== "?") { + result.push(parseInt(num)); + } else { + result.push(-1); + } + s = s.substring(i + 1); + } + if (result.length % 2 !== 0) { + throw new Error("parse error: odd number of fields"); + } + return [result, shouldCompileMatch]; +}; + +const testFowler = async (fileName: string): Promise => { + const rawStream = fs.createReadStream(path.join(FIXTURES_DIRNAME, fileName)); + const inputFile: NodeJS.ReadableStream = fileName.endsWith(".gz") + ? rawStream.pipe(zlib.createGunzip()) + : rawStream; + + let lineno = 0; + let lastRegexp = ""; + + for await (const line of readline.createInterface({ input: inputFile })) { + lineno += 1; + + if (!line || line[0] === "#") { + continue; + } + + const field = line.split("\t").filter((s) => s.length > 0); + for (let i = 0; i < field.length; i++) { + if (field[i] === "NULL") { + field[i] = ""; + } + if (field[i] === "NIL") { + continue; + } + } + + if (field.length === 0) { + continue; + } + + let flag = field[0]; + + switch (flag.charAt(0)) { + case "?": + case "&": + case "|": + case ";": + case "{": + case "}": { + flag = flag.substring(1); + if (!flag || flag === "") { + continue; + } + break; + } + case ":": { + const i = flag.indexOf(":", 1); + if (i < 0) { + continue; + } + flag = flag.substring(1 + i + 1); + break; + } + case "C": + case "N": + case "T": + case "0": + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + continue; + } + + if (field.length < 4) { + throw new Error(`${lineno}: too few fields: ${line}`); + } + + if (flag.indexOf("$") >= 0) { + field[1] = unquote(`"${field[1]}"`); + field[2] = unquote(`"${field[2]}"`); + } + + if (field[1] === "SAME") { + field[1] = lastRegexp; + } + lastRegexp = field[1]; + + const text = field[2]; + + const [, shouldCompileMatch] = parseFowlerResult(field[3]); + + for (let i = 0; i < flag.length; i++) { + let pattern = field[1]; + + let flags = RE2Flags.POSIX | RE2Flags.CLASS_NL; + switch (flag.charAt(i)) { + default: + continue; + case "E": + break; + case "L": + pattern = Utils.quoteMeta(pattern); + } + + if (flag.indexOf("i") >= 0) { + flags |= RE2Flags.FOLD_CASE; + } + + let re = null; + try { + re = RE2.compileImpl(pattern, flags); + } catch (_e) { + if (shouldCompileMatch[0]) { + throw new Error(`${lineno}: ${pattern} did not compile`); + } + continue; + } + + assert.strictEqual(shouldCompileMatch[0], true); + + const match = re.match(text); + assert.strictEqual(match, shouldCompileMatch[1]); + } + } +}; + +test("RE2 search", async () => { + await testRE2("re2-search.txt"); +}); + +test("RE2 exhaustive", { timeout: 2000000 }, async () => { + await testRE2("re2-exhaustive.txt.gz"); +}); + +test("RE2 fowler basic", async () => { + await testFowler("basic.dat"); +}); + +test("RE2 fowler null subexpr", async () => { + await testFowler("nullsubexpr.dat"); +}); + +test("RE2 fowler repetition", async () => { + await testFowler("repetition.dat"); +}); + +test("example", () => { + const re = RE2.compile("(?i:co(.)a)"); + assert.strictEqual(re.match("Copacobana"), true); + assert.strictEqual(re.match("xyz"), false); +}); diff --git a/packages/cel/src/re2/__tests__/Inst.test.ts b/packages/cel/src/re2/__tests__/Inst.test.ts new file mode 100644 index 0000000..bcab682 --- /dev/null +++ b/packages/cel/src/re2/__tests__/Inst.test.ts @@ -0,0 +1,49 @@ +import { describe, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { Inst } from "../Inst.js"; +import { RE2Flags } from "../RE2Flags.js"; + +describe("Inst.matchRune Array Search Logic", () => { + it("correctly matches using the linear search fast-path (length 4)", () => { + const inst = new Inst(Inst.RUNE); + inst.runes = [10, 20, 30, 40]; + inst.arg = 0; + + assert.strictEqual(inst.matchRune(9), false); + assert.strictEqual(inst.matchRune(10), true); + assert.strictEqual(inst.matchRune(15), true); + assert.strictEqual(inst.matchRune(20), true); + + assert.strictEqual(inst.matchRune(25), false); + + assert.strictEqual(inst.matchRune(30), true); + assert.strictEqual(inst.matchRune(35), true); + assert.strictEqual(inst.matchRune(41), false); + }); + + it("correctly matches using binary search for large arrays (length > 8)", () => { + const inst = new Inst(Inst.RUNE); + inst.runes = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]; + inst.arg = 0; + + assert.strictEqual(inst.matchRune(9), false); + + assert.strictEqual(inst.matchRune(15), true); + assert.strictEqual(inst.matchRune(45), false); + assert.strictEqual(inst.matchRune(55), true); + assert.strictEqual(inst.matchRune(85), false); + assert.strictEqual(inst.matchRune(95), true); + + assert.strictEqual(inst.matchRune(101), false); + }); + + it("correctly handles case-folding single runes", () => { + const inst = new Inst(Inst.RUNE); + inst.runes = ["a".codePointAt(0)!]; + inst.arg = RE2Flags.FOLD_CASE; + + assert.strictEqual(inst.matchRune("a".codePointAt(0)!), true); + assert.strictEqual(inst.matchRune("A".codePointAt(0)!), true); + assert.strictEqual(inst.matchRune("b".codePointAt(0)!), false); + }); +}); diff --git a/packages/cel/src/re2/__tests__/Parser.test.ts b/packages/cel/src/re2/__tests__/Parser.test.ts new file mode 100644 index 0000000..266abd8 --- /dev/null +++ b/packages/cel/src/re2/__tests__/Parser.test.ts @@ -0,0 +1,383 @@ +import { describe, test, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2Flags } from "../RE2Flags.js"; +import { RE2JSSyntaxException } from "../exceptions.js"; +import { Parser } from "../Parser.js"; +import { Unicode } from "../Unicode.js"; +import { dumpRegexp, mkCharClass } from "../__utils__/parser.js"; + +describe(".parse", () => { + const cases: [string, string | null][] = [ + ["a", "lit{a}"], + ["a.", "cat{lit{a}dot{}}"], + ["a.b", "cat{lit{a}dot{}lit{b}}"], + ["ab", "str{ab}"], + ["a.b.c", "cat{lit{a}dot{}lit{b}dot{}lit{c}}"], + ["abc", "str{abc}"], + ["a|^", "alt{lit{a}bol{}}"], + ["a|b", "cc{0x61-0x62}"], + ["(a)", "cap{lit{a}}"], + ["(a)|b", "alt{cap{lit{a}}lit{b}}"], + ["a*", "star{lit{a}}"], + ["a+", "plus{lit{a}}"], + ["a?", "que{lit{a}}"], + ["a{2}", "rep{2,2 lit{a}}"], + ["a{2,3}", "rep{2,3 lit{a}}"], + ["a{2,}", "rep{2,-1 lit{a}}"], + ["a*?", "nstar{lit{a}}"], + ["a+?", "nplus{lit{a}}"], + ["a??", "nque{lit{a}}"], + ["a{2}?", "nrep{2,2 lit{a}}"], + ["a{2,3}?", "nrep{2,3 lit{a}}"], + ["a{2,}?", "nrep{2,-1 lit{a}}"], + ["x{1001", "str{x{1001}"], + ["x{9876543210", "str{x{9876543210}"], + ["x{9876543210,", "str{x{9876543210,}"], + ["x{2,1", "str{x{2,1}"], + ["x{1,9876543210", "str{x{1,9876543210}"], + ["", "emp{}"], + ["|x|", "alt{emp{}lit{x}emp{}}"], + [".", "dot{}"], + ["^", "bol{}"], + ["$", "eol{}"], + ["\\|", "lit{|}"], + ["\\(", "lit{(}"], + ["\\)", "lit{)}"], + ["\\*", "lit{*}"], + ["\\+", "lit{+}"], + ["\\?", "lit{?}"], + ["{", "lit{{}"], + ["}", "lit{}}"], + ["\\.", "lit{.}"], + ["\\^", "lit{^}"], + ["\\$", "lit{$}"], + ["\\\\", "lit{\\}"], + ["[ace]", "cc{0x61 0x63 0x65}"], + ["[abc]", "cc{0x61-0x63}"], + ["[a-z]", "cc{0x61-0x7a}"], + ["[a]", "lit{a}"], + ["\\-", "lit{-}"], + ["-", "lit{-}"], + ["\\_", "lit{_}"], + ["abc", "str{abc}"], + ["abc|def", "alt{str{abc}str{def}}"], + ["abc|def|ghi", "alt{str{abc}str{def}str{ghi}}"], + + ["[[:lower:]]", "cc{0x61-0x7a}"], + ["[a-z]", "cc{0x61-0x7a}"], + ["[^[:lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}"], + ["[[:^lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}"], + ["(?i)[[:lower:]]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}"], + ["(?i)[a-z]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}"], + ["(?i)[^[:lower:]]", "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}"], + ["(?i)[[:^lower:]]", "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}"], + ["\\d", "cc{0x30-0x39}"], + ["\\D", "cc{0x0-0x2f 0x3a-0x10ffff}"], + ["\\s", "cc{0x9-0xa 0xc-0xd 0x20}"], + ["\\S", "cc{0x0-0x8 0xb 0xe-0x1f 0x21-0x10ffff}"], + ["\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a}"], + ["\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x10ffff}"], + ["(?i)\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a 0x17f 0x212a}"], + ["(?i)\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}"], + ["[^\\\\]", "cc{0x0-0x5b 0x5d-0x10ffff}"], + + ["\\p{Ascii}", "cc{0x0-0x7f}"], + ["\\P{Ascii}", "cc{0x80-0x10ffff}"], + ["\\p{^Ascii}", "cc{0x80-0x10ffff}"], + ["\\P{^Ascii}", "cc{0x0-0x7f}"], + ["\\p{Braille}", "cc{0x2800-0x28ff}"], + ["\\P{Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}"], + ["\\p{^Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}"], + ["\\P{^Braille}", "cc{0x2800-0x28ff}"], + ["\\pZ", "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}"], + ["[\\p{Braille}]", "cc{0x2800-0x28ff}"], + ["[\\P{Braille}]", "cc{0x0-0x27ff 0x2900-0x10ffff}"], + ["[\\p{^Braille}]", "cc{0x0-0x27ff 0x2900-0x10ffff}"], + ["[\\P{^Braille}]", "cc{0x2800-0x28ff}"], + ["[\\pZ]", "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}"], + ["\\p{Lu}", mkCharClass((r) => Unicode.isUpper(r))], + ["[\\p{Lu}]", mkCharClass((r) => Unicode.isUpper(r))], + [ + "(?i)[\\p{Lu}]", + mkCharClass((r) => { + if (Unicode.isUpper(r)) { + return true; + } + + for (let c = Unicode.simpleFold(r); c !== r; c = Unicode.simpleFold(c)) { + if (Unicode.isUpper(c)) { + return true; + } + } + return false; + }), + ], + ["\\p{Any}", "dot{}"], + ["\\p{^Any}", "cc{}"], + + ["[\\012-\\234]\\141", "cat{cc{0xa-0x9c}lit{a}}"], + ["[\\x{41}-\\x7a]\\x61", "cat{cc{0x41-0x7a}lit{a}}"], + + ["a{,2}", "str{a{,2}}"], + ["\\.\\^\\$\\\\", "str{.^$\\}"], + ["[a-zABC]", "cc{0x41-0x43 0x61-0x7a}"], + ["[^a]", "cc{0x0-0x60 0x62-0x10ffff}"], + ["[α-ε☺]", "cc{0x3b1-0x3b5 0x263a}"], + ["a*{", "cat{star{lit{a}}lit{{}}"], + + ["(?:ab)*", "star{str{ab}}"], + ["(ab)*", "star{cap{str{ab}}}"], + ["ab|cd", "alt{str{ab}str{cd}}"], + ["a(b|c)d", "cat{lit{a}cap{cc{0x62-0x63}}lit{d}}"], + + ["(?:a)", "lit{a}"], + ["(?:ab)(?:cd)", "str{abcd}"], + ["(?:a+b+)(?:c+d+)", "cat{plus{lit{a}}plus{lit{b}}plus{lit{c}}plus{lit{d}}}"], + ["(?:a+|b+)|(?:c+|d+)", "alt{plus{lit{a}}plus{lit{b}}plus{lit{c}}plus{lit{d}}}"], + ["(?:a|b)|(?:c|d)", "cc{0x61-0x64}"], + ["a|.", "dot{}"], + [".|a", "dot{}"], + ["(?:[abc]|A|Z|hello|world)", "alt{cc{0x41 0x5a 0x61-0x63}str{hello}str{world}}"], + ["(?:[abc]|A|Z)", "cc{0x41 0x5a 0x61-0x63}"], + + ["\\Q+|*?{[\\E", "str{+|*?{[}"], + ["\\Q+\\E+", "plus{lit{+}}"], + ["\\Qab\\E+", "cat{lit{a}plus{lit{b}}}"], + ["\\Q\\\\E", "lit{\\}"], + ["\\Q\\\\\\E", "str{\\\\}"], + + ["(?m)^", "bol{}"], + ["(?m)$", "eol{}"], + ["(?-m)^", "bot{}"], + ["(?-m)$", "eot{}"], + ["(?m)\\A", "bot{}"], + ["(?m)\\z", "eot{\\z}"], + ["(?-m)\\A", "bot{}"], + ["(?-m)\\z", "eot{\\z}"], + + ["(?Pa)", "cap{name:lit{a}}"], + ["(?a)", "cap{name:lit{a}}"], + [ + "(?Pf{0,10})(?Pb{0,10})", + "cat{cap{baz:rep{0,10 lit{f}}}cap{bag:rep{0,10 lit{b}}}}", + ], + [ + "(?f{0,10})(?b{0,10})", + "cat{cap{baz:rep{0,10 lit{f}}}cap{bag:rep{0,10 lit{b}}}}", + ], + + ["[Aa]", "litfold{A}"], + ["[\\x{100}\\x{101}]", "litfold{Ā}"], + ["[Δδ]", "litfold{Δ}"], + + ["abcde", "str{abcde}"], + ["[Aa][Bb]cd", "cat{strfold{AB}str{cd}}"], + + ["(?:.)", "dot{}"], + ["(?:A(?:A|a))", "cat{lit{A}litfold{A}}"], + ["(?:A|a)", "litfold{A}"], + ["A|(?:A|a)", "litfold{A}"], + ["(?s).", "dot{}"], + ["(?-s).", "dnl{}"], + ["(?:(?:^).)", "cat{bol{}dot{}}"], + ["(?-s)(?:(?:^).)", "cat{bol{}dnl{}}"], + ["[\\x00-\\x{10FFFF}]", "dot{}"], + ["[^\\x00-\\x{10FFFF}]", "cc{}"], + ["(?:[a][a-])", "cat{lit{a}cc{0x2d 0x61}}"], + + ["abc|x|abd", "alt{str{abc}lit{x}str{abd}}"], + + ["((((((((((x{2}){2}){2}){2}){2}){2}){2}){2}){2}))", null], + ["((((((((((x{1}){2}){2}){2}){2}){2}){2}){2}){2}){2})", null], + + [ + `${[...new Array(999)].map(() => "(").join("")}${[...new Array(999)].map(() => ")").join("")}`, + null, + ], + [ + `${[...new Array(999)].map(() => "(?:").join("")}${[...new Array(999)].map(() => ")*").join("")}`, + null, + ], + [`(${[...new Array(12345)].map(() => "|").join("")})`, null], + ]; + + const flags = RE2Flags.MATCH_NL | RE2Flags.PERL_X | RE2Flags.UNICODE_GROUPS; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input).slice(0, 100)} returns ${JSON.stringify(expected)}`, () => { + const re = Parser.parse(input, flags); + let parsedRe: string | null = null; + assert.doesNotThrow(() => { + parsedRe = dumpRegexp(re); + }); + if (expected !== null) { + assert.strictEqual(parsedRe, expected); + } + }); + } +}); + +describe("fold cases", () => { + const cases: [string, string][] = [ + ["AbCdE", "strfold{ABCDE}"], + ["[Aa]", "litfold{A}"], + ["a", "litfold{A}"], + ["A[F-g]", "cat{litfold{A}cc{0x41-0x7a 0x17f 0x212a}}"], + ["[[:upper:]]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}"], + ["[[:lower:]]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}"], + ]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { + const re = Parser.parse(input, RE2Flags.FOLD_CASE); + assert.strictEqual(dumpRegexp(re), expected); + }); + } +}); + +describe("literal cases", () => { + const cases: [string, string][] = [["(|)^$.[*+?]{5,10},\\", "str{(|)^$.[*+?]{5,10},\\}"]]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { + const re = Parser.parse(input, RE2Flags.LITERAL); + assert.strictEqual(dumpRegexp(re), expected); + }); + } +}); + +describe("match new line cases", () => { + const cases: [string, string][] = [ + [".", "dot{}"], + ["\n", "lit{\n}"], + ["[^a]", "cc{0x0-0x60 0x62-0x10ffff}"], + ["[a\\n]", "cc{0xa 0x61}"], + ]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { + const re = Parser.parse(input, RE2Flags.MATCH_NL); + assert.strictEqual(dumpRegexp(re), expected); + }); + } +}); + +describe("no match new line cases", () => { + const cases: [string, string][] = [ + [".", "dnl{}"], + ["\n", "lit{\n}"], + ["[^a]", "cc{0x0-0x9 0xb-0x60 0x62-0x10ffff}"], + ["[a\\n]", "cc{0xa 0x61}"], + ]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { + const re = Parser.parse(input, 0); + assert.strictEqual(dumpRegexp(re), expected); + }); + } +}); + +describe("invalid regexp cases", () => { + const invalidInputs: string[] = [ + "(", + ")", + "(a", + "(a|b|", + "(a|b", + "[a-z", + "([a-z)", + "x{1001}", + "x{9876543210}", + "x{2,1}", + "x{1,9876543210}", + "(?Pa", + "(?P", + "(?Pa)", + "(?P<>a)", + "(?a", + "(?", + "(?a)", + "(?<>a)", + "[a-Z]", + "(?i)[a-Z]", + "\\Q\\E*", + "a{100000}", + "a{100000,}", + "(?Pbar)(?Pbaz)", + "(?Pbar)(?baz)", + "(?bar)(?Pbaz)", + "(?bar)(?baz)", + "\\x", + "\\xv", + "^[a-z0-9\\–\\-'‘’]+$", + '[\\”\\“]"', + "[\\<\\>\\{\\}\\[\\]\\|\\”\\%\\~\\#]", + "((g{2,32}|q){1,32})", + "((((((((((x{2}){2}){2}){2}){2}){2}){2}){2}){2}){2})", + `${[...new Array(1000)].map(() => "(").join("")}${[...new Array(1000)].map(() => ")").join("")}`, + `${[...new Array(1000)].map(() => "(?:").join("")}${[...new Array(1000)].map(() => ")*").join("")}`, + `(${[...new Array(1000)].map(() => "(xx?)").join("")}){1000}`, + `${[...new Array(1000)].map(() => "(xx?){1000}").join("")}`, + `${[...new Array(27000)].map(() => "\\pL").join("")}`, + ]; + + for (const input of invalidInputs) { + test(`invalid ${JSON.stringify(input).slice(0, 80)} raise error`, () => { + assert.throws(() => Parser.parse(input, RE2Flags.PERL), RE2JSSyntaxException); + assert.throws(() => Parser.parse(input, RE2Flags.POSIX), RE2JSSyntaxException); + }); + } + + const validInPerl: string[] = [ + "[a-b-c]", + "\\Qabc\\E", + "\\Q*+?{[\\E", + "\\Q\\\\E", + "\\Q\\\\\\E", + "\\Q\\\\\\\\E", + "\\Q\\\\\\\\\\E", + "(?:a)", + "(?Pa)", + "(?a)", + ]; + + for (const input of validInPerl) { + test(`valid ${JSON.stringify(input)} in perl mode`, () => { + assert.doesNotThrow(() => Parser.parse(input, RE2Flags.PERL)); + }); + } + + const invalidInPerl: string[] = ["a++", "a**", "a?*", "a+*", "a{1}*", ".{1}{2}.{3}"]; + + for (const input of invalidInPerl) { + test(`invalid ${JSON.stringify(input)} in perl mode`, () => { + assert.throws(() => Parser.parse(input, RE2Flags.PERL), RE2JSSyntaxException); + }); + } +}); + +describe("large AST flat structures", () => { + it("should not exceed call stack size on massive alternations", () => { + const massiveAlternation = new Array(100000).fill("a").join("|"); + assert.doesNotThrow(() => { + Parser.parse(massiveAlternation, RE2Flags.PERL); + }); + }); + + it("should not exceed call stack size on massive concatenations", () => { + const massiveConcat = new Array(100000).fill("(a)").join(""); + assert.doesNotThrow(() => { + Parser.parse(massiveConcat, RE2Flags.PERL); + }); + }); +}); + +describe("Flag interactions", () => { + it("should parse \\p correctly with UNICODE_GROUPS enabled", () => { + const re = Parser.parse("\\p{Any}", RE2Flags.PERL); + assert.strictEqual(dumpRegexp(re), "dot{}"); + }); +}); diff --git a/packages/cel/src/re2/__tests__/Prefilter.test.ts b/packages/cel/src/re2/__tests__/Prefilter.test.ts new file mode 100644 index 0000000..f20b3ad --- /dev/null +++ b/packages/cel/src/re2/__tests__/Prefilter.test.ts @@ -0,0 +1,139 @@ +import { describe, test, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { Parser } from "../Parser.js"; +import { Simplify } from "../Simplify.js"; +import { PrefilterTree, Prefilter } from "../Prefilter.js"; +import { RE2Flags } from "../RE2Flags.js"; +import { RE2JS } from "../index.js"; +import { MachineInput } from "../MachineInput.js"; + +const dumpPrefilter = (pf: Prefilter | null): string => { + if (!pf) return "null"; + switch (pf.type) { + case Prefilter.Type.NONE: + return "NONE"; + case Prefilter.Type.EXACT: + return `EXACT("${pf.str}")`; + case Prefilter.Type.AND: + return `AND(${pf.subs.map(dumpPrefilter).join(", ")})`; + case Prefilter.Type.OR: + return `OR(${pf.subs.map(dumpPrefilter).join(", ")})`; + default: + return "UNKNOWN"; + } +}; + +const getPrefilterDump = (pattern: string, flags: number = RE2Flags.PERL): string => { + let re = Parser.parse(pattern, flags); + re = Simplify.simplify(re); + const pf = PrefilterTree.build(re); + return dumpPrefilter(pf); +}; + +describe("PrefilterTree.build AST Extraction", () => { + const cases: [string, string][] = [ + ["foo", 'EXACT("foo")'], + ["^foo$", 'EXACT("foo")'], + + ["foo.*bar", 'AND(EXACT("foo"), EXACT("bar"))'], + ["a.*b.*c", 'AND(EXACT("a"), EXACT("b"), EXACT("c"))'], + + ["foo|bar", 'OR(EXACT("foo"), EXACT("bar"))'], + ["apple|banana|cherry", 'OR(EXACT("apple"), EXACT("banana"), EXACT("cherry"))'], + + ["(foo|bar)baz", 'AND(OR(EXACT("foo"), EXACT("bar")), EXACT("baz"))'], + ["foo(bar|baz)qux", 'AND(EXACT("foo"), OR(EXACT("bar"), EXACT("baz")), EXACT("qux"))'], + + ["a+b", 'AND(EXACT("a"), EXACT("b"))'], + ["a{2,5}b", 'AND(EXACT("a"), EXACT("a"), EXACT("b"))'], + ["a?b", 'EXACT("b")'], + ["a*b", 'EXACT("b")'], + + ["foo|foo", 'OR(EXACT("foo"))'], + ["(a|a)b", 'AND(EXACT("a"), EXACT("b"))'], + ["a?b?c?", "NONE"], + + ["(?i)foo", "NONE"], + ["\\d+foo", 'EXACT("foo")'], + ["[a-z]+|foo", "NONE"], + ["a|b|c", "NONE"], + ]; + + for (const [pattern, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} builds prefilter ${JSON.stringify(expected)}`, () => { + assert.strictEqual(getPrefilterDump(pattern), expected); + }); + } +}); + +describe("Prefilter Evaluation (UTF-16 & UTF-8)", () => { + it("correctly evaluates EXACT filters", () => { + const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("foo", RE2Flags.PERL))); + + assert.strictEqual(pf.eval(MachineInput.fromUTF16("bar foo baz"), 0), true); + assert.strictEqual(pf.eval(MachineInput.fromUTF16("bar fox baz"), 0), false); + }); + + it("correctly evaluates AND filters", () => { + const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("foo.*bar", RE2Flags.PERL))); + + const input1 = MachineInput.fromUTF16("foo and then bar"); + assert.strictEqual(pf.eval(input1, 0), true); + + const input2 = MachineInput.fromUTF16("foo and then baz"); + assert.strictEqual(pf.eval(input2, 0), false); + }); + + it("correctly evaluates OR filters", () => { + const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("foo|bar", RE2Flags.PERL))); + + const input1 = MachineInput.fromUTF16("I have a bar"); + assert.strictEqual(pf.eval(input1, 0), true); + + const input2 = MachineInput.fromUTF16("I have a baz"); + assert.strictEqual(pf.eval(input2, 0), false); + }); +}); + +describe("Engine Integration", () => { + it("securely bails out early during unanchored tests", () => { + const re = RE2JS.compile("error.*critical"); + + assert.strictEqual(re.test("There was an error that was critical"), true); + assert.strictEqual(re.test("There was an error that was minor"), false); + }); + + it("does not interfere with anchored execution", () => { + const re = RE2JS.compile("^foo.*bar$"); + + assert.strictEqual(re.testExact("foo and bar"), true); + assert.strictEqual(re.testExact("foo and baz"), false); + }); +}); + +describe("Advanced Prefilter Evaluation", () => { + it("handles complex AND/OR logic branches correctly", () => { + const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("(foo|bar)baz", RE2Flags.PERL))); + + assert.strictEqual(pf.eval(MachineInput.fromUTF16("foobaz"), 0), true); + assert.strictEqual(pf.eval(MachineInput.fromUTF16("barbaz"), 0), true); + assert.strictEqual(pf.eval(MachineInput.fromUTF16("foo"), 0), false); + assert.strictEqual(pf.eval(MachineInput.fromUTF16("baz"), 0), false); + assert.strictEqual(pf.eval(MachineInput.fromUTF16("quxbaz"), 0), false); + }); + + it("evaluates emojis and multi-byte unicode safely", () => { + const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("🚀.*🌕", RE2Flags.PERL))); + + assert.strictEqual(pf.eval(MachineInput.fromUTF16("To the 🚀 and then 🌕!"), 0), true); + assert.strictEqual(pf.eval(MachineInput.fromUTF16("To the 🚀 and then back!"), 0), false); + }); + + it("respects end boundaries on bounded input buffers", () => { + const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("hidden", RE2Flags.PERL))); + const text = "visible hidden"; + + const utf16Input = MachineInput.fromUTF16(text, 0, 7); + assert.strictEqual(pf.eval(utf16Input, 0), false); + }); +}); diff --git a/packages/cel/src/re2/__tests__/RE2Compile.test.ts b/packages/cel/src/re2/__tests__/RE2Compile.test.ts new file mode 100644 index 0000000..0e52d97 --- /dev/null +++ b/packages/cel/src/re2/__tests__/RE2Compile.test.ts @@ -0,0 +1,55 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2 } from "../RE2.js"; + +describe(".compile", () => { + const cases: [string, string | null][] = [ + ["", null], + [".", null], + ["^.$", null], + ["a", null], + ["a*", null], + ["a+", null], + ["a?", null], + ["a|b", null], + ["a*|b*", null], + ["(a*|b)(c*|d)", null], + ["[a-z]", null], + ["[a-abc-c\\-\\]\\[]", null], + ["[a-z]+", null], + ["[abc]", null], + ["[^1234]", null], + ["[^\n]", null], + ["..|.#|..", null], + ["\\!\\\\", null], + ["abc]", null], + ["a??", null], + ["*", "missing argument to repetition operator: `*`"], + ["+", "missing argument to repetition operator: `+`"], + ["?", "missing argument to repetition operator: `?`"], + ["(abc", "missing closing ): `(abc`"], + ["abc)", "unexpected ): `abc)`"], + ["x[a-z", "missing closing ]: `[a-z`"], + ["[z-a]", "invalid character class range: `z-a`"], + ["abc\\", "trailing backslash at end of expression"], + ["a**", "invalid nested repetition operator: `**`"], + ["a*+", "invalid nested repetition operator: `*+`"], + ["\\x", "invalid escape sequence: `\\x`"], + ["\\p", "invalid character class range: `\\p`"], + ["\\p{", "invalid character class range: `\\p{`"], + ["((g{2,32}|q){1,32})", "invalid repeat count: `{1,32}`"], + ["((g{2,20}|q){1,20}){0,40}", "invalid repeat count: `{0,40}`"], + [[...new Array(1000)].map(() => "(xx?){1000}").join(""), "expression too large"], + ]; + + for (const [input, expected] of cases) { + test(`input ${JSON.stringify(input)} compile raise error ${JSON.stringify(expected)}`, () => { + try { + RE2.compile(input); + assert.strictEqual(null, expected); + } catch (e) { + assert.strictEqual((e as Error).message, `error parsing regexp: ${expected}`); + } + }); + } +}); diff --git a/packages/cel/src/re2/__tests__/RE2ExecuteEngine.test.ts b/packages/cel/src/re2/__tests__/RE2ExecuteEngine.test.ts new file mode 100644 index 0000000..d1dc941 --- /dev/null +++ b/packages/cel/src/re2/__tests__/RE2ExecuteEngine.test.ts @@ -0,0 +1,53 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2 } from "../RE2.js"; +import { DFA } from "../DFA.js"; +import { RE2Flags } from "../RE2Flags.js"; +import { MachineInput } from "../MachineInput.js"; +import { Prefilter } from "../Prefilter.js"; + +describe("Literal Fast-Path Routing", () => { + test("bails out early using literal fast path for strictly literal unanchored regexes", (t) => { + const prefilterSpy = t.mock.method(Prefilter.prototype, "eval"); + const dfaSpy = t.mock.method(DFA.prototype, "match"); + + const re = RE2.compile("hello"); + const result = re.match("say hello world"); + + assert.strictEqual(result, true); + assert.strictEqual(prefilterSpy.mock.callCount(), 0); + assert.strictEqual(dfaSpy.mock.callCount(), 0); + }); + + test("literal fast path boolean match works correctly", () => { + const re = RE2.compile("world"); + assert.strictEqual(re.match("hello world!"), true); + assert.strictEqual(re.match("hello earth!"), false); + }); + + test("literal fast path perfectly handles ANCHOR_BOTH (testExact)", (t) => { + const dfaSpy = t.mock.method(DFA.prototype, "match"); + + const re = RE2.compile("hello"); + + const matchInput = MachineInput.fromUTF16("hello"); + assert.notStrictEqual( + re.executeEngine(matchInput, 0, RE2Flags.ANCHOR_BOTH, 0), + null, + ); + + const noMatchInput1 = MachineInput.fromUTF16("hello world"); + assert.strictEqual( + re.executeEngine(noMatchInput1, 0, RE2Flags.ANCHOR_BOTH, 0), + null, + ); + + const noMatchInput2 = MachineInput.fromUTF16("say hello"); + assert.strictEqual( + re.executeEngine(noMatchInput2, 0, RE2Flags.ANCHOR_BOTH, 0), + null, + ); + + assert.strictEqual(dfaSpy.mock.callCount(), 0); + }); +}); diff --git a/packages/cel/src/re2/__tests__/RE2Match.test.ts b/packages/cel/src/re2/__tests__/RE2Match.test.ts new file mode 100644 index 0000000..d9eaf59 --- /dev/null +++ b/packages/cel/src/re2/__tests__/RE2Match.test.ts @@ -0,0 +1,13 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2 } from "../RE2.js"; +import { FIND_TESTS } from "../__fixtures__/find.js"; + +describe("match", () => { + for (const testPattern of FIND_TESTS) { + test(String(testPattern), () => { + const re = RE2.compile(testPattern.pat); + assert.strictEqual(re.match(testPattern.text), testPattern.matches.length > 0); + }); + } +}); diff --git a/packages/cel/src/re2/__tests__/RE2QuoteMeta.test.ts b/packages/cel/src/re2/__tests__/RE2QuoteMeta.test.ts new file mode 100644 index 0000000..be69aec --- /dev/null +++ b/packages/cel/src/re2/__tests__/RE2QuoteMeta.test.ts @@ -0,0 +1,40 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2 } from "../RE2.js"; +import { RE2JS } from "../index.js"; +import { Utils } from "../Utils.js"; + +const cases: [string, string, string, boolean][] = [ + ["", "", "", true], + ["foo", "foo", "foo", true], + ["foo\\.\\$", "foo\\\\\\.\\\\\\$", "foo.$", true], + ["foo.\\$", "foo\\.\\\\\\$", "foo", false], + [ + "!@#$%^&*()_+-=[{]}\\|,<.>/?~", + "!@#\\$%\\^&\\*\\(\\)_\\+-=\\[\\{\\]\\}\\\\\\|,<\\.>/\\?~", + "!@#", + false, + ], +]; + +describe("quoteMeta", () => { + for (const [pattern, output] of cases) { + test(`quote meta: pattern ${JSON.stringify(pattern)} quoted to ${JSON.stringify(output)}`, () => { + const quoted = Utils.quoteMeta(pattern); + assert.strictEqual(Utils.quoteMeta(pattern), output); + assert.strictEqual(RE2JS.quote(pattern), output); + if (pattern && pattern.length > 0) { + const re = RE2.compile(quoted); + assert.strictEqual(re.match(`abc${pattern}def`), true); + } + }); + } + + for (const [pattern, output, literal, isLiteral] of cases) { + test(`literal prefix: pattern ${JSON.stringify(pattern)} quoted to ${JSON.stringify(output)} and literal ${JSON.stringify(literal)} (isLiteral: ${isLiteral})`, () => { + const re = RE2.compile(pattern); + assert.strictEqual(re.prefix, literal); + assert.strictEqual(re.prefixComplete, isLiteral); + }); + } +}); diff --git a/packages/cel/src/re2/__tests__/StressBoundary.test.ts b/packages/cel/src/re2/__tests__/StressBoundary.test.ts new file mode 100644 index 0000000..2c725ad --- /dev/null +++ b/packages/cel/src/re2/__tests__/StressBoundary.test.ts @@ -0,0 +1,97 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; + +describe("stress: boundary conditions", () => { + test("empty pattern matches empty string", () => { + const re = RE2JS.compile(""); + assert.strictEqual(re.testExact(""), true); + assert.strictEqual(re.test(""), true); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.testExact("abc"), false); + }); + + test("single char at MAX_RUNE (0x10FFFF)", () => { + const maxCharPattern = String.fromCodePoint(0x10ffff); + const re = RE2JS.compile(maxCharPattern); + assert.strictEqual(re.testExact(maxCharPattern), true); + assert.strictEqual(re.test(`x${maxCharPattern}y`), true); + }); + + test("char class covering full range", () => { + const re = RE2JS.compile("^.$"); + assert.strictEqual(re.testExact("a"), true); + assert.strictEqual(re.testExact(String.fromCodePoint(0x10ffff)), true); + assert.strictEqual(re.testExact("\n"), false); + }); + + test("dot with DOTALL flag", () => { + const re = RE2JS.compile("(?s)^.$"); + assert.strictEqual(re.testExact("\n"), true); + }); + + test("deeply nested non-capturing groups", () => { + const depth = 100; + const pattern = "(?:".repeat(depth) + "a" + ")".repeat(depth); + const re = RE2JS.compile(pattern); + assert.strictEqual(re.testExact("a"), true); + assert.strictEqual(re.testExact("b"), false); + }); + + test("deeply nested captures", () => { + const depth = 50; + const pattern = "(".repeat(depth) + "a" + ")".repeat(depth); + const re = RE2JS.compile(pattern); + assert.strictEqual(re.testExact("a"), true); + assert.strictEqual(re.groupCount(), depth); + }); + + test("zero-repetition prefix", () => { + const re = RE2JS.compile("a{0}b"); + assert.strictEqual(re.testExact("b"), true); + assert.strictEqual(re.testExact("ab"), false); + }); + + test("repetition lower bound 0", () => { + const re = RE2JS.compile("a{0,3}"); + assert.strictEqual(re.testExact(""), true); + assert.strictEqual(re.testExact("aaa"), true); + assert.strictEqual(re.testExact("aaaa"), false); + }); + + test("large bounded repetition", () => { + const re = RE2JS.compile("a{10,20}"); + assert.strictEqual(re.testExact("a".repeat(9)), false); + assert.strictEqual(re.testExact("a".repeat(10)), true); + assert.strictEqual(re.testExact("a".repeat(15)), true); + assert.strictEqual(re.testExact("a".repeat(20)), true); + assert.strictEqual(re.testExact("a".repeat(21)), false); + }); + + test("alternation with empty branch", () => { + const re = RE2JS.compile("(a|)b"); + assert.strictEqual(re.testExact("b"), true); + assert.strictEqual(re.testExact("ab"), true); + }); + + test("massive alternation", () => { + const alts = Array.from({ length: 1000 }, (_, i) => + String.fromCodePoint(0x61 + (i % 26)), + ).join("|"); + const re = RE2JS.compile(alts); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test("z"), true); + }); + + test("huge input matching", () => { + const re = RE2JS.compile("needle"); + const haystack = "a".repeat(100000) + "needle" + "a".repeat(100000); + assert.strictEqual(re.test(haystack), true); + }); + + test("empty char class", () => { + const re = RE2JS.compile("^[^\\x00-\\x{10FFFF}]$"); + assert.strictEqual(re.testExact("a"), false); + assert.strictEqual(re.testExact(""), false); + }); +}); diff --git a/packages/cel/src/re2/__tests__/StressErrorRecovery.test.ts b/packages/cel/src/re2/__tests__/StressErrorRecovery.test.ts new file mode 100644 index 0000000..1f1250f --- /dev/null +++ b/packages/cel/src/re2/__tests__/StressErrorRecovery.test.ts @@ -0,0 +1,65 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; +import { RE2JSSyntaxException } from "../exceptions.js"; + +describe("stress: parser error recovery", () => { + const compileGoodAfterBad = (badPattern: string, goodPattern: string): void => { + assert.throws(() => RE2JS.compile(badPattern), RE2JSSyntaxException); + assert.doesNotThrow(() => RE2JS.compile(goodPattern)); + }; + + test("unclosed char class recovers", () => { + compileGoodAfterBad("[a-z", "abc"); + }); + + test("incomplete property escape recovers", () => { + compileGoodAfterBad("\\p{", "xyz"); + }); + + test("unclosed named capture recovers", () => { + compileGoodAfterBad("(?P { + assert.doesNotThrow(() => RE2JS.compile("a{")); + assert.doesNotThrow(() => RE2JS.compile("a{1,2,3}")); + compileGoodAfterBad("a{1001}", "xyz"); + compileGoodAfterBad("a{100000,}", "xyz"); + }); + + test("unknown property name recovers", () => { + compileGoodAfterBad("\\p{NotAValidName}", "abc"); + }); + + test("unmatched close paren recovers", () => { + compileGoodAfterBad("abc)", "xyz"); + }); + + test("unmatched open paren recovers", () => { + compileGoodAfterBad("(abc", "xyz"); + }); + + test("nested repetition recovers", () => { + compileGoodAfterBad("a**", "xyz"); + compileGoodAfterBad("a{1}{2}", "xyz"); + }); + + test("invalid escape recovers", () => { + compileGoodAfterBad("\\x", "xyz"); + compileGoodAfterBad("\\u", "xyz"); + }); + + test("many errors in sequence", () => { + const bad = ["(", ")", "[", "\\p{", "\\x", "a**", "a{1,0}"]; + for (const p of bad) { + assert.throws(() => RE2JS.compile(p)); + } + assert.strictEqual(RE2JS.compile("hello").test("hello"), true); + }); + + test("massive alternation stays under limit", () => { + const pat = `(${Array(12345).fill("").join("|")})`; + assert.doesNotThrow(() => RE2JS.compile(pat)); + }); +}); diff --git a/packages/cel/src/re2/__tests__/StressFlags.test.ts b/packages/cel/src/re2/__tests__/StressFlags.test.ts new file mode 100644 index 0000000..543f917 --- /dev/null +++ b/packages/cel/src/re2/__tests__/StressFlags.test.ts @@ -0,0 +1,80 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; + +describe("stress: flag interactions", () => { + test("(?i)(?m) case-insensitive + multiline", () => { + const re = RE2JS.compile("(?im)^[a-z]+$"); + assert.strictEqual(re.test("hello"), true); + assert.strictEqual(re.test("HELLO"), true); + assert.strictEqual(re.test("Hello\nWORLD"), true); + assert.strictEqual(re.test("1234"), false); + }); + + test("(?s)(?i) dotall + case-insensitive", () => { + const re = RE2JS.compile("(?si)a.b"); + assert.strictEqual(re.test("A\nB"), true); + assert.strictEqual(re.test("aXb"), true); + }); + + test("(?i) with Unicode category", () => { + const re = RE2JS.compile("(?i)^\\p{Lu}+$"); + assert.strictEqual(re.test("HELLO"), true); + assert.strictEqual(re.test("hello"), true); + assert.strictEqual(re.test("123"), false); + }); + + test("(?-i) turns off case-insensitive within scope", () => { + const re = RE2JS.compile("(?i)a(?-i:b)c"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("ABC"), false); + assert.strictEqual(re.test("Abc"), true); + }); + + test("multiline ^ and $ behavior", () => { + const re = RE2JS.compile("(?m)^foo$"); + assert.strictEqual(re.test("foo"), true); + assert.strictEqual(re.test("bar\nfoo\nbaz"), true); + assert.strictEqual(re.test("barfoo"), false); + }); + + test("default (non-multiline) $ matches end-of-text only", () => { + const re = RE2JS.compile("foo$"); + assert.strictEqual(re.test("foo"), true); + assert.strictEqual(re.test("foo\n"), false); + assert.strictEqual(re.test("foox"), false); + }); + + test("\\A and \\z always anchor text boundaries", () => { + const re = RE2JS.compile("(?m)\\Afoo\\z"); + assert.strictEqual(re.testExact("foo"), true); + assert.strictEqual(re.test("bar\nfoo"), false); + }); + + test("DOTALL does not affect line anchors", () => { + const re = RE2JS.compile("(?s)^foo$"); + assert.strictEqual(re.test("foo"), true); + assert.strictEqual(re.test("bar\nfoo"), false); + }); + + test("case-insensitive with ASCII char class", () => { + const re = RE2JS.compile("(?i)[a-z]+"); + assert.strictEqual(re.test("HELLO"), true); + assert.strictEqual(re.test("hello"), true); + assert.strictEqual(re.test("123"), false); + }); + + test("case-insensitive with single-fold letters", () => { + const re = RE2JS.compile("(?i)k"); + assert.strictEqual(re.test("k"), true); + assert.strictEqual(re.test("K"), true); + assert.strictEqual(re.test(String.fromCodePoint(0x212a)), true); + }); + + test("case-insensitive with long-s orbit", () => { + const re = RE2JS.compile("(?i)s"); + assert.strictEqual(re.test("s"), true); + assert.strictEqual(re.test("S"), true); + assert.strictEqual(re.test(String.fromCodePoint(0x017f)), true); + }); +}); diff --git a/packages/cel/src/re2/__tests__/StressUnicode.test.ts b/packages/cel/src/re2/__tests__/StressUnicode.test.ts new file mode 100644 index 0000000..3e8dd1d --- /dev/null +++ b/packages/cel/src/re2/__tests__/StressUnicode.test.ts @@ -0,0 +1,89 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; + +describe("stress: Unicode edge cases", () => { + test("char class with supplementary plane range", () => { + const re = RE2JS.compile("^[\\x{10000}-\\x{10FFFF}]$"); + assert.strictEqual(re.testExact(String.fromCodePoint(0x10000)), true); + assert.strictEqual(re.testExact(String.fromCodePoint(0x10ffff)), true); + assert.strictEqual(re.testExact(String.fromCodePoint(0x1f600)), true); + assert.strictEqual(re.testExact("a"), false); + }); + + test("emoji in literal", () => { + const emoji = String.fromCodePoint(0x1f600); + const re = RE2JS.compile(`^${emoji}$`); + assert.strictEqual(re.testExact(emoji), true); + assert.strictEqual(re.testExact("a"), false); + }); + + test("mixed script property escapes", () => { + const re = RE2JS.compile("^\\p{Greek}\\p{Latin}$"); + assert.strictEqual(re.testExact("αa"), true); + assert.strictEqual(re.testExact("aa"), false); + assert.strictEqual(re.testExact("αα"), false); + }); + + test("\\p{L} matches all Unicode letters", () => { + const re = RE2JS.compile("^\\p{L}+$"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("ΑΒΓ"), true); + assert.strictEqual(re.test("日本語"), true); + assert.strictEqual(re.test("مرحبا"), true); + assert.strictEqual(re.test("123"), false); + }); + + test("negated \\P{L}", () => { + const re = RE2JS.compile("^\\P{L}+$"); + assert.strictEqual(re.test("123"), true); + assert.strictEqual(re.test("!@#"), true); + assert.strictEqual(re.test("abc"), false); + assert.strictEqual(re.test("αβγ"), false); + }); + + test("\\p{Any} matches anything", () => { + const re = RE2JS.compile("^\\p{Any}$"); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test(String.fromCodePoint(0x10ffff)), true); + }); + + test("Unicode 16.0 new script: Garay", () => { + const re = RE2JS.compile("^\\p{Garay}+$"); + assert.strictEqual(re.test(String.fromCodePoint(0x10d40)), true); + assert.strictEqual(re.test("a"), false); + }); + + test("surrogate char class \\p{Cs}", () => { + const re = RE2JS.compile("^\\p{Cs}$"); + assert.strictEqual(re.testExact(String.fromCharCode(0xd800)), true); + assert.strictEqual(re.testExact(String.fromCharCode(0xdfff)), true); + assert.strictEqual(re.testExact("a"), false); + }); + + test("repetition over supplementary char", () => { + const emoji = String.fromCodePoint(0x1f600); + const re = RE2JS.compile(`${emoji}{3}`); + assert.strictEqual(re.test(emoji + emoji + emoji), true); + assert.strictEqual(re.test(emoji + emoji), false); + }); + + test("char class with supplementary and BMP mix", () => { + const re = RE2JS.compile("^[a\\x{1F600}]+$"); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test(String.fromCodePoint(0x1f600)), true); + assert.strictEqual(re.test(`a${String.fromCodePoint(0x1f600)}a`), true); + assert.strictEqual(re.test("b"), false); + }); + + test("word boundary near supplementary chars", () => { + const re = RE2JS.compile("\\bword\\b"); + const supp = String.fromCodePoint(0x1d4d0); + assert.strictEqual(re.test(`${supp}word${supp}`), true); + }); + + test("non-BMP case folding stays identity (RE2 limitation)", () => { + const re = RE2JS.compile(`(?i)${String.fromCodePoint(0x1d4d0)}`); + assert.strictEqual(re.test(String.fromCodePoint(0x1d4d0)), true); + }); +}); diff --git a/packages/cel/src/re2/__tests__/Unicode.test.ts b/packages/cel/src/re2/__tests__/Unicode.test.ts new file mode 100644 index 0000000..a58cc7a --- /dev/null +++ b/packages/cel/src/re2/__tests__/Unicode.test.ts @@ -0,0 +1,129 @@ +import { describe, test, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { Unicode } from "../Unicode.js"; +import { UnicodeTables } from "../UnicodeTables.js"; +import { codePoint } from "../__utils__/chars.js"; + +describe("#isUpper", () => { + const cases: [number, boolean][] = [ + [115, false], + [83, true], + [503, true], + [469, true], + [474, false], + [940, false], + ]; + + for (const [input, expected] of cases) { + test(`#isUpper(${input}) === ${expected}`, () => { + assert.strictEqual(Unicode.isUpper(input), expected); + }); + } +}); + +describe("#simpleFold", () => { + const cases: [number, number][] = [ + [65, 97], + [97, 65], + [83, 115], + [115, 383], + [383, 83], + [75, 107], + [107, 8490], + [8490, 75], + [49, 49], + [57, 57], + ]; + + for (const [input, expected] of cases) { + test(`#simpleFold(${input}) === ${expected}`, () => { + assert.strictEqual(Unicode.simpleFold(input), expected); + }); + } +}); + +const genEqualsIgnoreCases = (): [number, number, boolean][] => { + const testCases: [number, number, boolean][] = [ + [codePoint("{"), codePoint("{"), true], + [codePoint("é"), codePoint("É"), true], + [codePoint("Ú"), codePoint("ú"), true], + [codePoint("\u212A"), codePoint("K"), true], + [codePoint("\u212A"), codePoint("k"), true], + [codePoint("\u212A"), codePoint("a"), false], + [codePoint("ü"), codePoint("ű"), false], + [codePoint("b"), codePoint("k"), false], + [codePoint("C"), codePoint("x"), false], + [codePoint("/"), codePoint("_"), false], + [codePoint("d"), codePoint(")"), false], + [codePoint("@"), codePoint("`"), false], + ]; + + for (let r = codePoint("a"); r <= codePoint("z"); r++) { + const u = r - (codePoint("a") - codePoint("A")); + testCases.push([r, r, true], [u, u, true], [r, u, true], [u, r, true]); + } + + return testCases; +}; + +describe("#equalsIgnoreCase", () => { + for (const [r1, r2, expected] of genEqualsIgnoreCases()) { + test(`#equalsIgnoreCase(${r1}, ${r2}) === ${expected}`, () => { + assert.strictEqual(Unicode.equalsIgnoreCase(r1, r2), expected); + }); + } +}); + +describe("UnicodeTables VLQ Decompression", () => { + it("should decompress the Zl (Line Separator) table correctly", () => { + const zlTable = UnicodeTables.CATEGORIES.get("Zl")!; + + assert.strictEqual(zlTable.length, 1); + assert.strictEqual(zlTable.getLo(0), 0x2028); + assert.strictEqual(zlTable.getHi(0), 0x2028); + assert.strictEqual(zlTable.getStride(0), 1); + }); + + it("should decompress the Zp (Paragraph Separator) table correctly", () => { + const zpTable = UnicodeTables.CATEGORIES.get("Zp")!; + + assert.strictEqual(zpTable.length, 1); + assert.strictEqual(zpTable.getLo(0), 0x2029); + assert.strictEqual(zpTable.getHi(0), 0x2029); + assert.strictEqual(zpTable.getStride(0), 1); + }); + + it("should decompress the CASE_ORBIT map correctly", () => { + const orbit = UnicodeTables.CASE_ORBIT; + + assert.strictEqual(orbit.has(65), false); + assert.strictEqual(orbit.has(75), false); + assert.strictEqual(orbit.has(83), false); + + assert.strictEqual(orbit.has(115), true); + assert.strictEqual(orbit.get(115), 383); + + assert.strictEqual(orbit.has(0x0131), true); + assert.strictEqual(orbit.get(0x0131), 0x0131); + + assert.strictEqual(orbit.has(107), true); + assert.strictEqual(orbit.get(107), 8490); + }); + + it("should decompress the Nd (Decimal Digits) table correctly with strides", () => { + const ndTable = UnicodeTables.CATEGORIES.get("Nd")!; + + assert.ok(ndTable.length > 0); + + let foundAsciiDigits = false; + for (let i = 0; i < ndTable.length; i++) { + if (ndTable.getLo(i) === 48 && ndTable.getHi(i) === 57) { + foundAsciiDigits = true; + assert.strictEqual(ndTable.getStride(i), 1); + break; + } + } + + assert.strictEqual(foundAsciiDigits, true); + }); +}); diff --git a/packages/cel/src/re2/__tests__/UnicodeConformance.test.ts b/packages/cel/src/re2/__tests__/UnicodeConformance.test.ts new file mode 100644 index 0000000..77aef5f --- /dev/null +++ b/packages/cel/src/re2/__tests__/UnicodeConformance.test.ts @@ -0,0 +1,116 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; +import { UnicodeTables } from "../UnicodeTables.js"; +// @ts-expect-error — no types published for this package +import unicodePropertyValueAliases from "unicode-property-value-aliases"; + +const aliasesToNames = unicodePropertyValueAliases.get("General_Category") as Map; + +const loadCodePoints = async ( + kind: "General_Category" | "Script", + longName: string, +): Promise => { + const mod = await import(`@unicode/unicode-16.0.0/${kind}/${longName}/code-points.js`); + return mod.default as number[]; +}; + +const samplePositives = (points: number[], n = 100): number[] => { + if (points.length <= n) return points; + const out = [points[0], points[points.length - 1]]; + const step = Math.floor(points.length / (n - 2)); + for (let i = step; i < points.length - step; i += step) out.push(points[i]); + return out; +}; + +const NEGATIVE_PROBES: number[] = (() => { + const probes: number[] = []; + const step = Math.floor(0x10ffff / 200); + for (let cp = 0; cp <= 0x10ffff; cp += step) probes.push(cp); + return probes; +})(); + +const SHRINKING_PROPERTIES: ReadonlySet = new Set(["Cn", "Unknown"]); + +const assertConformance = ( + propertyName: string, + kind: "General_Category" | "Script", + canonical: number[], +): void => { + const canonicalSet = new Set(canonical); + const platformPattern = `^\\p{${kind}=${propertyName}}$`; + let platformRegex: RegExp; + try { + platformRegex = new RegExp(platformPattern, "u"); + } catch { + const re = RE2JS.compile(`^\\p{${propertyName}}$`); + for (const cp of samplePositives(canonical)) { + assert.strictEqual(re.testExact(String.fromCodePoint(cp)), true); + } + return; + } + + const reBare = RE2JS.compile(`^\\p{${propertyName}}$`); + const reCombined = RE2JS.compile(`^[\\p{${propertyName}}]$`); + + for (const cp of samplePositives(canonical)) { + const s = String.fromCodePoint(cp); + if (!platformRegex.test(s)) continue; + assert.strictEqual(reBare.testExact(s), true); + assert.strictEqual(reCombined.testExact(s), true); + } + + for (const cp of NEGATIVE_PROBES) { + const s = String.fromCodePoint(cp); + if (canonicalSet.has(cp)) continue; + if (platformRegex.test(s)) continue; + assert.strictEqual(reBare.testExact(s), false); + assert.strictEqual(reCombined.testExact(s), false); + } + + if (!SHRINKING_PROPERTIES.has(propertyName)) { + for (const cp of samplePositives(canonical)) { + const s = String.fromCodePoint(cp); + assert.strictEqual(reBare.testExact(s), true); + assert.strictEqual(reCombined.testExact(s), true); + } + } +}; + +describe("Unicode 16.0 conformance — general categories", () => { + const aliases = Array.from(UnicodeTables.STABLE_CATEGORY_NAMES); + for (const alias of aliases) { + test(`\\p{${alias}} matches Unicode 16.0`, async () => { + const longName = aliasesToNames.get(alias); + if (!longName) { + throw new Error(`no canonical long name for category alias '${alias}'`); + } + const canonical = await loadCodePoints("General_Category", longName); + assertConformance(alias, "General_Category", canonical); + }); + } +}); + +describe("Unicode 16.0 conformance — scripts", () => { + const scriptNames = Array.from(UnicodeTables.STABLE_SCRIPT_NAMES); + for (const name of scriptNames) { + test(`\\p{${name}} matches Unicode 16.0`, async () => { + const canonical = await loadCodePoints("Script", name); + assertConformance(name, "Script", canonical); + }); + } +}); + +describe("Unicode 16.0 conformance — scripts added in 16.0", () => { + const newScriptNames = Array.from(UnicodeTables.NEW_SCRIPT_NAMES); + for (const name of newScriptNames) { + test(`\\p{${name}} matches Unicode 16.0 (full scan)`, async () => { + const canonical = await loadCodePoints("Script", name); + assertConformance(name, "Script", canonical); + const reBare = RE2JS.compile(`^\\p{${name}}$`); + for (const cp of canonical) { + assert.strictEqual(reBare.testExact(String.fromCodePoint(cp)), true); + } + }); + } +}); diff --git a/packages/cel/src/re2/__tests__/edge-cases.test.ts b/packages/cel/src/re2/__tests__/edge-cases.test.ts new file mode 100644 index 0000000..45e7529 --- /dev/null +++ b/packages/cel/src/re2/__tests__/edge-cases.test.ts @@ -0,0 +1,470 @@ +import { describe, test, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; +import { RE2 } from "../RE2.js"; +import { MachineInput } from "../MachineInput.js"; +import { RE2Flags } from "../RE2Flags.js"; + +describe("Edge cases and bug hunting", () => { + describe("Empty patterns and inputs", () => { + it("empty pattern matches empty string", () => { + const re = RE2JS.compile(""); + assert.strictEqual(re.testExact(""), true); + }); + + it("empty pattern matches any non-empty string via test (zero-width)", () => { + const re = RE2JS.compile(""); + assert.strictEqual(re.test("anything"), true); + }); + + it("empty pattern + testExact on non-empty fails", () => { + const re = RE2JS.compile(""); + assert.strictEqual(re.testExact("x"), false); + }); + + it("(?:) non-capturing empty group matches empty", () => { + const re = RE2JS.compile("(?:)"); + assert.strictEqual(re.testExact(""), true); + }); + + it("^$ matches empty string", () => { + const re = RE2JS.compile("^$"); + assert.strictEqual(re.testExact(""), true); + assert.strictEqual(re.testExact("x"), false); + }); + + it("^$ does not match any content", () => { + const re = RE2JS.compile("^$"); + assert.strictEqual(re.test("hello"), false); + }); + + it("(?m)^$ matches at line boundaries", () => { + const re = RE2JS.compile("(?m)^$"); + assert.strictEqual(re.test("a\n\nb"), true); + assert.strictEqual(re.test("abc"), false); + }); + }); + + describe("Repetition edge cases", () => { + it("a{0} matches empty string", () => { + const re = RE2JS.compile("^a{0}$"); + assert.strictEqual(re.test(""), true); + assert.strictEqual(re.test("a"), false); + }); + + it("a{0,0} matches empty string", () => { + const re = RE2JS.compile("^a{0,0}$"); + assert.strictEqual(re.test(""), true); + }); + + it("a{0,1} matches empty or single a", () => { + const re = RE2JS.compile("^a{0,1}$"); + assert.strictEqual(re.test(""), true); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test("aa"), false); + }); + + it("zero-width repetition inside group", () => { + const re = RE2JS.compile("^(a*)$"); + assert.strictEqual(re.test(""), true); + assert.strictEqual(re.test("aaaa"), true); + }); + }); + + describe("Unicode edge cases", () => { + it("pattern at MAX_RUNE boundary", () => { + const re = RE2JS.compile("."); + const maxRune = String.fromCodePoint(0x10ffff); + assert.strictEqual(re.testExact(maxRune), true); + }); + + it("surrogate pair matches as single rune with dot", () => { + const re = RE2JS.compile("^.$"); + assert.strictEqual(re.testExact("😊"), true); + }); + + it("character class with supplementary plane", () => { + const re = RE2JS.compile("[\u{1F600}-\u{1F64F}]+"); + assert.strictEqual(re.testExact("😊😊😊"), true); + }); + + it("surrogate pair at end of string", () => { + const re = RE2JS.compile("abc😊$"); + assert.strictEqual(re.test("abc😊"), true); + }); + + it("word boundary with non-ASCII word chars", () => { + const re = RE2JS.compile("\\bhello\\b"); + assert.strictEqual(re.test("hello world"), true); + assert.strictEqual(re.test("éhello"), true); + }); + }); + + describe("Anchor semantics", () => { + it("^^ double anchors", () => { + const re = RE2JS.compile("^^abc"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("xabc"), false); + }); + + it("$$ double end anchors", () => { + const re = RE2JS.compile("abc$$"); + assert.strictEqual(re.test("abc"), true); + }); + + it("\\A at start only (no multiline equivalent)", () => { + const re = RE2JS.compile("(?m)\\Aabc"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("x\nabc"), false); + }); + + it("\\z at end only", () => { + const re = RE2JS.compile("(?m)abc\\z"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("abc\nx"), false); + }); + }); + + describe("Word boundary + anchor correctness", () => { + it("\\babc\\b does not match when followed by word char", () => { + const re = RE2JS.compile("\\babc\\b"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("abcx"), false); + assert.strictEqual(re.test("xabc"), false); + assert.strictEqual(re.test(" abc "), true); + assert.strictEqual(re.test(" abcx"), false); + assert.strictEqual(re.test("xabc "), false); + }); + + it("\\babc\\b under NFA fallback agrees with DFA", () => { + const re = RE2JS.compile("\\babc\\b"); + re.re2Input.dfa.failed = true; + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("abcx"), false); + assert.strictEqual(re.test(" abc "), true); + assert.strictEqual(re.test("xabc"), false); + }); + }); + + describe("Word boundaries", () => { + it("\\b at start of input", () => { + const re = RE2JS.compile("\\babc"); + assert.strictEqual(re.test("abc"), true); + }); + + it("\\b at end of input", () => { + const re = RE2JS.compile("abc\\b"); + assert.strictEqual(re.test("abc"), true); + }); + + it("\\B does not match at text boundary", () => { + const re = RE2JS.compile("\\Babc"); + assert.strictEqual(re.test("abc"), false); + assert.strictEqual(re.test("xabc"), true); + }); + + it("\\b between numbers and letters (no boundary)", () => { + const re = RE2JS.compile("\\b1A\\b"); + assert.strictEqual(re.test("1A"), true); + assert.strictEqual(re.test("x1A"), false); + }); + }); + + describe("Execute engine directly with anchors", () => { + it("ANCHOR_START from pos 0 only matches if the pattern starts at 0", () => { + const re = RE2.compile("abc"); + assert.notStrictEqual( + re.executeEngine(MachineInput.fromUTF16("abcxyz"), 0, RE2Flags.ANCHOR_START, 0), + null, + ); + assert.strictEqual( + re.executeEngine(MachineInput.fromUTF16("xabc"), 0, RE2Flags.ANCHOR_START, 0), + null, + ); + }); + + it("ANCHOR_BOTH requires exact full-input match", () => { + const re = RE2.compile("abc"); + assert.notStrictEqual( + re.executeEngine(MachineInput.fromUTF16("abc"), 0, RE2Flags.ANCHOR_BOTH, 0), + null, + ); + assert.strictEqual( + re.executeEngine(MachineInput.fromUTF16("abcd"), 0, RE2Flags.ANCHOR_BOTH, 0), + null, + ); + assert.strictEqual( + re.executeEngine(MachineInput.fromUTF16("xabc"), 0, RE2Flags.ANCHOR_BOTH, 0), + null, + ); + }); + + it("DFA and NFA agree on all anchor modes", () => { + const re = RE2.compile("abc"); + const inputStr = "xabcy"; + const dfaUA = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.UNANCHORED, 0); + const dfaAS = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_START, 0); + const dfaAB = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_BOTH, 0); + + re.dfa.failed = true; + const nfaUA = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.UNANCHORED, 0); + const nfaAS = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_START, 0); + const nfaAB = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_BOTH, 0); + + assert.strictEqual(Boolean(nfaUA), Boolean(dfaUA)); + assert.strictEqual(Boolean(nfaAS), Boolean(dfaAS)); + assert.strictEqual(Boolean(nfaAB), Boolean(dfaAB)); + }); + }); + + describe("Case folding edge cases", () => { + it("(?i) with Kelvin symbol", () => { + const re = RE2JS.compile("(?i)k"); + assert.strictEqual(re.test("k"), true); + assert.strictEqual(re.test("K"), true); + assert.strictEqual(re.test("\u212A"), true); + }); + + it("(?i) with long-s", () => { + const re = RE2JS.compile("(?i)s"); + assert.strictEqual(re.test("s"), true); + assert.strictEqual(re.test("S"), true); + assert.strictEqual(re.test("\u017F"), true); + }); + + it("(?i) with mixed case string", () => { + const re = RE2JS.compile("(?i)^hello$"); + assert.strictEqual(re.test("HELLO"), true); + assert.strictEqual(re.test("hElLo"), true); + assert.strictEqual(re.test("hello"), true); + }); + }); + + describe("Alternation with empty branches", () => { + it("a|b|c matches any of the three", () => { + const re = RE2JS.compile("^(a|b|c)$"); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test("b"), true); + assert.strictEqual(re.test("c"), true); + assert.strictEqual(re.test("d"), false); + }); + + it("empty branch in alternation", () => { + const re = RE2JS.compile("^(a|)$"); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test(""), true); + }); + + it("leading empty branch", () => { + const re = RE2JS.compile("^(|a)$"); + assert.strictEqual(re.test("a"), true); + assert.strictEqual(re.test(""), true); + }); + }); + + describe("Escape sequences at boundaries", () => { + it("\\x escape", () => { + const re = RE2JS.compile("\\x41"); + assert.strictEqual(re.test("A"), true); + }); + + it("\\x{...} extended escape", () => { + const re = RE2JS.compile("\\x{1F600}"); + assert.strictEqual(re.test("😀"), true); + }); + + it("\\n matches newline", () => { + const re = RE2JS.compile("a\\nb"); + assert.strictEqual(re.test("a\nb"), true); + }); + }); + + describe("Prefilter corner cases", () => { + it("literal fast-path with repeated characters", () => { + const re = RE2JS.compile("aaa"); + assert.strictEqual(re.test("xxaaaxx"), true); + assert.strictEqual(re.test("aa"), false); + }); + + it("literal fast-path with Unicode", () => { + const re = RE2JS.compile("café"); + assert.strictEqual(re.test("le café ouvert"), true); + assert.strictEqual(re.test("no coffee here"), false); + }); + + it("literal ANCHOR_BOTH with prefix extension", () => { + const re = RE2JS.compile("exact"); + assert.strictEqual(re.testExact("exact"), true); + assert.strictEqual(re.testExact("exactly"), false); + assert.strictEqual(re.testExact("not exact"), false); + }); + }); + + describe("Simplify edge cases", () => { + it("nested quantifiers in simplify", () => { + const re = RE2JS.compile("(a{2}){3}"); + assert.strictEqual(re.testExact("aaaaaa"), true); + assert.strictEqual(re.testExact("aaaaa"), false); + }); + + it("quantifier on empty match", () => { + const re = RE2JS.compile("^(?:){5}$"); + assert.strictEqual(re.test(""), true); + }); + + it("alternation of empties", () => { + const re = RE2JS.compile("^(?:||)$"); + assert.strictEqual(re.test(""), true); + assert.strictEqual(re.test("x"), false); + }); + }); + + describe("DFA and NFA equivalence on tricky patterns", () => { + const trickyCases: Array<[string, string, boolean]> = [ + ["\\bfoo\\b", "nofoo foo that", true], + ["\\b\\w+\\b", "hello world", true], + ["^\\w+$", "hello", true], + ["^\\w+$", "hello world", false], + ["(?m)^abc$", "xyz\nabc\ndef", true], + ["\\Bfoo\\B", "xfooy", true], + ["(?m)^(?:a|b)+$", "a\nb\nab", true], + ["(?m)^(?:a|b)+$", "a\nx\nb", true], + ["(?m)^(?:a|b)+$", "ax\nby\nab", true], + ["(?m)^(?:a|b)+$", "ax\nby\ncd", false], + ["(?m)^(?:a|b)+$", "ab", true], + ["^$", "", true], + ["^.*$", "", true], + ["^.*$", "anything", true], + ["$", "", true], + ["$", "a", true], + ]; + + for (const [pattern, input, expected] of trickyCases) { + test(`DFA matches /${pattern}/ against ${JSON.stringify(input)} => ${expected}`, () => { + const re = RE2JS.compile(pattern); + assert.strictEqual(re.test(input), expected); + }); + } + + for (const [pattern, input, expected] of trickyCases) { + test(`NFA fallback matches /${pattern}/ against ${JSON.stringify(input)} => ${expected}`, () => { + const re = RE2JS.compile(pattern); + re.re2Input.dfa.failed = true; + assert.strictEqual(re.test(input), expected); + }); + } + }); + + describe("Special escape sequences", () => { + it("\\Q...\\E with regex metacharacters", () => { + const re = RE2JS.compile("\\Q.+*?(){}[]|^$\\E"); + assert.strictEqual(re.test(".+*?(){}[]|^$"), true); + assert.strictEqual(re.test("a"), false); + }); + + it("\\Q...\\E without closing \\E goes to end", () => { + const re = RE2JS.compile("foo\\Q.*$"); + assert.strictEqual(re.test("foo.*$"), true); + assert.strictEqual(re.test("foobar"), false); + }); + + it("\\Q\\E empty quoted section", () => { + const re = RE2JS.compile("a\\Q\\Eb"); + assert.strictEqual(re.test("ab"), true); + }); + }); + + describe("DOTALL vs newline", () => { + it(". does not match newline without DOTALL", () => { + const re = RE2JS.compile("^.+$"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("a\nb"), false); + }); + + it(". matches newline with (?s) DOTALL", () => { + const re = RE2JS.compile("(?s)^.+$"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("a\nb"), true); + }); + + it("[\\s\\S] matches all chars without DOTALL", () => { + const re = RE2JS.compile("^[\\s\\S]+$"); + assert.strictEqual(re.test("a\nb\tc"), true); + }); + }); + + describe("Unicode property interactions", () => { + it("negated Unicode property [^\\p{L}]", () => { + const re = RE2JS.compile("^[^\\p{L}]+$"); + assert.strictEqual(re.testExact("123 !@#"), true); + assert.strictEqual(re.testExact("abc"), false); + assert.strictEqual(re.testExact("αβγ"), false); + }); + + it("\\P{L} is non-letter", () => { + const re = RE2JS.compile("^\\P{L}+$"); + assert.strictEqual(re.testExact("123"), true); + assert.strictEqual(re.testExact("abc"), false); + }); + + it("combined Unicode properties", () => { + const re = RE2JS.compile("^[\\p{L}\\p{N}]+$"); + assert.strictEqual(re.testExact("abc123"), true); + assert.strictEqual(re.testExact("αβγ123"), true); + assert.strictEqual(re.testExact("abc!"), false); + }); + }); + + describe("POSIX classes (RE2 syntax)", () => { + it("[[:alpha:]] matches letters", () => { + const re = RE2JS.compile("^[[:alpha:]]+$"); + assert.strictEqual(re.testExact("abc"), true); + assert.strictEqual(re.testExact("ABC"), true); + assert.strictEqual(re.testExact("abc123"), false); + }); + + it("[[:digit:]] matches digits", () => { + const re = RE2JS.compile("^[[:digit:]]+$"); + assert.strictEqual(re.testExact("123"), true); + assert.strictEqual(re.testExact("abc"), false); + }); + + it("negated POSIX class [[:^alpha:]]", () => { + const re = RE2JS.compile("^[[:^alpha:]]+$"); + assert.strictEqual(re.testExact("123"), true); + assert.strictEqual(re.testExact("abc"), false); + }); + }); + + describe("Named groups (parsing only, no capture extraction)", () => { + it("(?P...) parses and matches", () => { + const re = RE2JS.compile("(?P\\w+)"); + assert.strictEqual(re.test("hello"), true); + }); + + it("(?...) Perl-style named group is also accepted", () => { + const re = RE2JS.compile("(?\\w+)"); + assert.strictEqual(re.test("hello"), true); + assert.deepStrictEqual({ ...re.namedGroups() }, { word: 1 }); + }); + + it("namedGroups() returns group name map", () => { + const re = RE2JS.compile("(?P\\w+)\\s+(?P\\w+)"); + assert.deepStrictEqual({ ...re.namedGroups() }, { first: 1, last: 2 }); + }); + }); + + describe("Parser cache correctness (identity-based Map)", () => { + it("deeply nested captures parse without height/size cache collision", () => { + const deepPattern = "(" + "(?:(?:".repeat(100) + "a" + ")*)*".repeat(100) + ")"; + assert.doesNotThrow(() => RE2JS.compile(deepPattern)); + }); + + it("many parallel captures with same shape", () => { + const pattern = "^" + "(a)".repeat(100) + "$"; + const re = RE2JS.compile(pattern); + assert.strictEqual(re.test("a".repeat(100)), true); + assert.strictEqual(re.test("a".repeat(99)), false); + }); + }); +}); diff --git a/packages/cel/src/re2/__tests__/index.test.ts b/packages/cel/src/re2/__tests__/index.test.ts new file mode 100644 index 0000000..f31f5e0 --- /dev/null +++ b/packages/cel/src/re2/__tests__/index.test.ts @@ -0,0 +1,217 @@ +import { describe, test, it } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; +import { RE2JSSyntaxException } from "../exceptions.js"; + +it("compile", () => { + const p = RE2JS.compile("abc"); + assert.strictEqual(p.pattern(), "abc"); + assert.strictEqual(p.flags(), 0); +}); + +it("compile exception with duplicate groups", () => { + assert.throws( + () => RE2JS.compile("(?P.*)(?P.*"), + (e: Error) => e.message.includes("error parsing regexp: duplicate capture group name: `any`"), + ); +}); + +it(".toString", () => { + assert.strictEqual(RE2JS.compile("abc").toString(), "abc"); +}); + +it("compile flags", () => { + const p = RE2JS.compile("abc", 5); + assert.strictEqual(p.pattern(), "abc"); + assert.strictEqual(p.flags(), 5); +}); + +it("syntax error", () => { + const compile = () => RE2JS.compile("abc("); + assert.throws( + compile, + (e: Error) => e.message.includes("error parsing regexp: missing closing ): `abc(`"), + ); + + let error: RE2JSSyntaxException | null = null; + try { + compile(); + } catch (e) { + error = e as RE2JSSyntaxException; + } + + assert.notStrictEqual(error, null); + assert.strictEqual(error!.getDescription(), "missing closing )"); + assert.strictEqual(error!.message, "error parsing regexp: missing closing ): `abc(`"); + assert.strictEqual(error!.getPattern(), "abc("); +}); + +describe("matches no flags", () => { + const source = String.fromCodePoint(110781); + const cases: [string, string, string][] = [ + ["ab+c", "abbbc", "cbbba"], + ["ab.*c", "abxyzc", "ab\nxyzc"], + ["^ab.*c$", "abc", "xyz\nabc\ndef"], + [source, source, "blah"], + [`\\Q${source}\\E`, source, "blah"], + ]; + + for (const [regexp, match, nonMatch] of cases) { + test(`regexp ${JSON.stringify(regexp)} match ${JSON.stringify(match)} and not match ${JSON.stringify(nonMatch)}`, () => { + assert.strictEqual(RE2JS.matches(regexp, match), true); + assert.strictEqual(RE2JS.matches(regexp, nonMatch), false); + }); + } +}); + +describe("matches with flags", () => { + const cases: [string, number, string, string][] = [ + ["ab+c", 0, "abbbc", "cbba"], + ["ab+c", RE2JS.CASE_INSENSITIVE, "abBBc", "cbbba"], + ["ab.*c", 0, "abxyzc", "ab\nxyzc"], + ["ab.*c", RE2JS.DOTALL, "ab\nxyzc", "aB\nxyzC"], + ["ab.*c", RE2JS.DOTALL | RE2JS.CASE_INSENSITIVE, "aB\nxyzC", "z"], + ["^ab.*c$", 0, "abc", "xyz\nabc\ndef"], + ["^ab.*c$", RE2JS.MULTILINE, "abc", "xyz\nabc\ndef"], + ["^ab.*c$", RE2JS.MULTILINE, "abc", ""], + ["^ab.*c$", RE2JS.DOTALL | RE2JS.MULTILINE, "ab\nc", "AB\nc"], + ["^ab.*c$", RE2JS.DOTALL | RE2JS.MULTILINE | RE2JS.CASE_INSENSITIVE, "AB\nc", "z"], + ]; + + for (const [regexp, flags, match, nonMatch] of cases) { + test(`regexp ${JSON.stringify(regexp)} with flags ${flags} match ${JSON.stringify(match)} and not match ${JSON.stringify(nonMatch)}`, () => { + const p = RE2JS.compile(regexp, flags); + assert.strictEqual(p.matches(match), true); + assert.strictEqual(p.matches(nonMatch), false); + }); + } +}); + +describe(".test (Unanchored DFA Match)", () => { + const cases: [string, string, boolean][] = [ + ["foo", "foo", true], + ["foo", "a foo b", true], + ["foo", "bar", false], + ["(?i)foo", "FoO", true], + ["^[a-z]+$", "hello", true], + ["^[a-z]+$", "hello 123", false], + ["enters.*battlefield", "When this creature enters the battlefield, it deals 3 damage", true], + ["[0-9]+ mana", "Add 1 mana of any color", true], + ]; + + for (const [pattern, input, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} with input ${JSON.stringify(input)} will return ${expected}`, () => { + const re = RE2JS.compile(pattern); + assert.strictEqual(re.test(input), expected); + }); + } +}); + +describe(".testExact (Anchored DFA Match)", () => { + const cases: [string, string, boolean][] = [ + ["foo", "foo", true], + ["foo", "a foo b", false], + ["foo", "foobar", false], + ["[a-z]+", "hello", true], + ["[a-z]+", "hello 123", false], + ["(?i)foo", "FOO", true], + ["[0-9A-Fa-f]+", "1A4F", true], + ["[0-9A-Fa-f]+", "1A4F-xyz", false], + ]; + + for (const [pattern, input, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} with input ${JSON.stringify(input)} will return ${expected}`, () => { + const re = RE2JS.compile(pattern); + assert.strictEqual(re.testExact(input), expected); + }); + } +}); + +describe("group count", () => { + const cases: [string, number][] = [ + ["(.*)ab(.*)a", 2], + ["(.*)(ab)(.*)a", 3], + ["(.*)((a)b)(.*)a", 4], + ["(.*)(\\(ab)(.*)a", 3], + ["(.*)(\\(a\\)b)(.*)a", 3], + ]; + + for (const [pattern, count] of cases) { + test(`pattern ${JSON.stringify(pattern)} have groups ${count}`, () => { + const p = RE2JS.compile(pattern); + assert.strictEqual(p.groupCount(), count); + }); + } +}); + +describe("named groups", () => { + const cases: [string, Record][] = [ + ["(?P\\d{2})", { foo: 1 }], + ["\\d{2}", {}], + ["hello", {}], + ["(.*)", {}], + ["(?P.*)", { any: 1 }], + ["(?P.*)(?P.*)", { foo: 1, bar: 2 }], + ]; + + for (const [pattern, expected] of cases) { + test(`pattern ${JSON.stringify(pattern)} named groups ${JSON.stringify(expected)}`, () => { + assert.deepStrictEqual({ ...RE2JS.compile(pattern).namedGroups() }, expected); + }); + } +}); + +it("quote", () => { + const regexp = RE2JS.quote("ab+c"); + const match = "ab+c"; + const nonMatch = "abc"; + + assert.strictEqual(RE2JS.matches(regexp, match), true); + assert.strictEqual(RE2JS.matches(regexp, nonMatch), false); +}); + +it("email regex", () => { + const p = RE2JS.compile("[\\w\\.]+@[\\w\\.]+"); + assert.strictEqual(p.matches("test@example.com"), true); + assert.strictEqual(p.matches("test"), false); +}); + +it("date regex", () => { + const p = RE2JS.compile("([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])"); + assert.strictEqual(p.matches("2023-10-12"), true); + assert.strictEqual(p.matches("2023-02-02"), true); + assert.strictEqual(p.matches("300"), false); + assert.strictEqual(p.matches("example 2023-02-02 date"), false); +}); + +describe("Core Unicode Properties (Ascii, Assigned, Lc)", () => { + it("compiles without error", () => { + assert.doesNotThrow(() => RE2JS.compile("\\p{Ascii}")); + assert.doesNotThrow(() => RE2JS.compile("\\p{Assigned}")); + assert.doesNotThrow(() => RE2JS.compile("\\p{Lc}")); + }); + + it("matches \\p{Ascii} correctly", () => { + const p = RE2JS.compile("^\\p{Ascii}+$"); + + assert.strictEqual(p.matches("abc123!@#\x7F"), true); + assert.strictEqual(p.matches("abc😊"), false); + }); + + it("matches \\p{Lc} (Cased Letters) correctly", () => { + const p = RE2JS.compile("^\\p{Lc}+$"); + + assert.strictEqual(p.matches("aBcDeFéÜ"), true); + assert.strictEqual(p.matches("aBcDeF1"), false); + assert.strictEqual(p.matches("aBcDeF "), false); + }); + + it("matches \\p{Assigned} correctly (Inverse of Cn)", () => { + const p = RE2JS.compile("^\\p{Assigned}+$"); + + assert.strictEqual(p.matches("abc123!@#😊"), true); + + const unassignedChar = String.fromCodePoint(0x0378); + assert.strictEqual(p.matches(unassignedChar), false); + }); +}); diff --git a/packages/cel/src/re2/__tests__/stability.test.ts b/packages/cel/src/re2/__tests__/stability.test.ts new file mode 100644 index 0000000..21b5c73 --- /dev/null +++ b/packages/cel/src/re2/__tests__/stability.test.ts @@ -0,0 +1,273 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { RE2JS } from "../index.js"; + +describe("RE2JS Stability and Anti-ReDoS Guarantees", () => { + describe("Catastrophic Backtracking Immunity (ReDoS)", () => { + const assertLinearTime = (regexStr: string, inputStr: string, expectedMatch: boolean): void => { + const re = RE2JS.compile(regexStr); + const start = Date.now(); + const result = re.matches(inputStr); + const elapsed = Date.now() - start; + + assert.strictEqual(result, expectedMatch); + assert.ok(elapsed < 50); + }; + + test("Defeats classic nested repetition ReDoS: (a+)+b", () => { + assertLinearTime("^(a+)+b$", `${"a".repeat(60)}!`, false); + }); + + test("Defeats overlapping alternation ReDoS: (a|a?)+", () => { + assertLinearTime("^(a|a?)+$", `${"a".repeat(60)}!`, false); + }); + + test("Defeats OWASP Email Validation ReDoS", () => { + const emailRegex = "^([a-zA-Z0-9_.-])+@(([a-zA-Z0-9-])+.)+([a-zA-Z0-9]{2,4})+$"; + const maliciousEmail = `${"a".repeat(60)}@${"a".repeat(60)}.`; + assertLinearTime(emailRegex, maliciousEmail, false); + }); + + test("Defeats OWASP Whitespace / Content Exhaustion ReDoS", () => { + const whitespaceRegex = "^.*[ \\t]+.*$"; + const maliciousWhitespace = ` ${"\\t ".repeat(40)} `; + assertLinearTime(whitespaceRegex, maliciousWhitespace, true); + }); + + test("Defeats Path/URL Parsing ReDoS", () => { + const pathRegex = "^(/[^/]+)+$"; + const maliciousPath = `${"/a".repeat(60)}/`; + assertLinearTime(pathRegex, maliciousPath, false); + }); + }); + + describe("Infinite Loop & Memory Explosion Protections", () => { + test("Safely matches massive strings without exceeding Call Stack Size", () => { + const re = RE2JS.compile("a*b"); + const hugeString = `${"a".repeat(1000000)}b`; + assert.strictEqual(re.matches(hugeString), true); + }); + + test("Gracefully handles empty strings without crashing", () => { + const re1 = RE2JS.compile(".*"); + assert.strictEqual(re1.matches(""), true); + + const re2 = RE2JS.compile("a+"); + assert.strictEqual(re2.matches(""), false); + }); + + test("Properly scales multi-byte surrogate pairs (Emojis) in execution", () => { + const re = RE2JS.compile("^.$"); + assert.strictEqual(re.matches("😊"), true); + + const reEmoji = RE2JS.compile("^\\p{So}+$"); + assert.strictEqual(reEmoji.matches("😊🚀👽"), true); + }); + + test("DFA State Explosion limits are enforced (OOM Protection)", () => { + const re = RE2JS.compile(".*a.*b.*c"); + re.re2Input.dfa.stateLimit = 5; + assert.strictEqual(re.test("zzzaaazzzbbbzzzccczzz"), true); + }); + }); + + describe("NFA Fallback Correctness (DFA state explosion)", () => { + const forceNfaFallback = (regexStr: string, flags: number = 0) => { + const re = RE2JS.compile(regexStr, flags); + re.re2Input.dfa.failed = true; + return re; + }; + + describe("literal and simple patterns", () => { + test("matches simple literals", () => { + const re = forceNfaFallback("hello"); + assert.strictEqual(re.test("hello"), true); + assert.strictEqual(re.test("say hello world"), true); + assert.strictEqual(re.test("xyz"), false); + }); + + test("matches character classes", () => { + const re = forceNfaFallback("[a-z]+"); + assert.strictEqual(re.testExact("hello"), true); + assert.strictEqual(re.testExact("Hello"), false); + assert.strictEqual(re.test("XYZabcXYZ"), true); + }); + + test("matches negated character classes", () => { + const re = forceNfaFallback("[^0-9]+"); + assert.strictEqual(re.testExact("abc"), true); + assert.strictEqual(re.testExact("abc1"), false); + }); + }); + + describe("repetition", () => { + test("handles star (*)", () => { + const re = forceNfaFallback("a*b"); + assert.strictEqual(re.test("b"), true); + assert.strictEqual(re.test("ab"), true); + assert.strictEqual(re.test("aaaab"), true); + assert.strictEqual(re.test("c"), false); + }); + + test("handles plus (+)", () => { + const re = forceNfaFallback("a+b"); + assert.strictEqual(re.test("ab"), true); + assert.strictEqual(re.test("aaaab"), true); + assert.strictEqual(re.test("b"), false); + }); + + test("handles question (?)", () => { + const re = forceNfaFallback("colou?r"); + assert.strictEqual(re.test("color"), true); + assert.strictEqual(re.test("colour"), true); + assert.strictEqual(re.test("colouur"), false); + }); + + test("handles bounded repetition {m,n}", () => { + const re = forceNfaFallback("^a{2,4}$"); + assert.strictEqual(re.test("a"), false); + assert.strictEqual(re.test("aa"), true); + assert.strictEqual(re.test("aaaa"), true); + assert.strictEqual(re.test("aaaaa"), false); + }); + }); + + describe("alternation", () => { + test("handles simple alternation", () => { + const re = forceNfaFallback("foo|bar|baz"); + assert.strictEqual(re.test("foo"), true); + assert.strictEqual(re.test("bar"), true); + assert.strictEqual(re.test("baz"), true); + assert.strictEqual(re.test("qux"), false); + }); + + test("handles overlapping alternation", () => { + const re = forceNfaFallback("(abc|abd)"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("abd"), true); + assert.strictEqual(re.test("abe"), false); + }); + }); + + describe("anchors and empty-width assertions", () => { + test("handles begin-text ^", () => { + const re = forceNfaFallback("^abc"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("xabc"), false); + }); + + test("handles end-text $", () => { + const re = forceNfaFallback("abc$"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("abcx"), false); + }); + + test("handles both anchors ^...$", () => { + const re = forceNfaFallback("^foo$"); + assert.strictEqual(re.test("foo"), true); + assert.strictEqual(re.test("xfoo"), false); + }); + + test("handles \\A and \\z", () => { + const re = forceNfaFallback("\\Aabc\\z"); + assert.strictEqual(re.test("abc"), true); + assert.strictEqual(re.test("abcd"), false); + }); + + test("handles word boundaries \\b", () => { + const re = forceNfaFallback("\\bword\\b"); + assert.strictEqual(re.test("a word here"), true); + assert.strictEqual(re.test("sword"), false); + assert.strictEqual(re.test("words"), false); + }); + + test("handles non-word-boundaries \\B", () => { + const re = forceNfaFallback("\\Babc\\B"); + assert.strictEqual(re.test("xabcx"), true); + }); + + test("handles multiline ^ and $", () => { + const re = forceNfaFallback("(?m)^foo$"); + assert.strictEqual(re.test("bar\nfoo\nbaz"), true); + assert.strictEqual(re.test("barfoo"), false); + }); + }); + + describe("testExact (ANCHOR_BOTH)", () => { + test("requires full string match", () => { + const re = forceNfaFallback("[0-9]+"); + assert.strictEqual(re.testExact("12345"), true); + assert.strictEqual(re.testExact("12345abc"), false); + assert.strictEqual(re.testExact("abc12345"), false); + }); + + test("empty input with empty-matching pattern", () => { + const re = forceNfaFallback(".*"); + assert.strictEqual(re.testExact(""), true); + }); + + test("empty input with non-empty pattern", () => { + const re = forceNfaFallback("a+"); + assert.strictEqual(re.testExact(""), false); + }); + }); + + describe("case insensitivity", () => { + test("handles (?i) flag", () => { + const re = forceNfaFallback("(?i)hello"); + assert.strictEqual(re.test("HELLO"), true); + assert.strictEqual(re.test("HeLLo"), true); + assert.strictEqual(re.test("goodbye"), false); + }); + + test("handles case-insensitive char classes", () => { + const re = forceNfaFallback("(?i)[a-z]+"); + assert.strictEqual(re.testExact("ABCdef"), true); + }); + }); + + describe("Unicode", () => { + test("handles Unicode properties \\p{L}", () => { + const re = forceNfaFallback("^\\p{L}+$"); + assert.strictEqual(re.test("héllo"), true); + assert.strictEqual(re.test("αβγ"), true); + assert.strictEqual(re.test("123"), false); + }); + + test("handles surrogate pairs", () => { + const re = forceNfaFallback("^.+$"); + assert.strictEqual(re.test("😊"), true); + assert.strictEqual(re.test("😊🚀👽"), true); + }); + }); + + describe("NFA fallback produces same results as unrestricted DFA", () => { + const equivalenceCases: Array<[string, string, boolean]> = [ + ["hello", "hello world", true], + ["hello", "goodbye", false], + ["^\\d{3}-\\d{4}$", "555-1234", true], + ["^\\d{3}-\\d{4}$", "555-12345", false], + ["[a-zA-Z_][a-zA-Z0-9_]*", "valid_name123", true], + ["a{3,}", "aaa", true], + ["^a{3,}$", "aa", false], + ["(?:abc){2,3}", "abcabc", true], + ["^(?:abc){2,3}$", "abc", false], + [".*\\.(jpg|png|gif)$", "photo.jpg", true], + [".*\\.(jpg|png|gif)$", "photo.txt", false], + ["^[A-Z][a-z]+$", "Hello", true], + ["^[A-Z][a-z]+$", "hello", false], + ["^[0-9]{4}-[0-9]{2}-[0-9]{2}$", "2026-04-16", true], + ["^[0-9]{4}-[0-9]{2}-[0-9]{2}$", "abcd-ef-gh", false], + ]; + + for (const [pattern, input, expected] of equivalenceCases) { + test(`NFA produces same result as DFA for /${pattern}/ on ${JSON.stringify(input)}`, () => { + const reDfa = RE2JS.compile(pattern); + const reNfa = forceNfaFallback(pattern); + assert.strictEqual(reDfa.test(input), expected); + assert.strictEqual(reNfa.test(input), expected); + }); + } + }); + }); +}); diff --git a/packages/cel/src/re2/__utils__/chars.ts b/packages/cel/src/re2/__utils__/chars.ts new file mode 100644 index 0000000..a118f7b --- /dev/null +++ b/packages/cel/src/re2/__utils__/chars.ts @@ -0,0 +1 @@ +export const codePoint = (v: string): number => v.codePointAt(0)! diff --git a/packages/cel/src/re2/__utils__/parser.ts b/packages/cel/src/re2/__utils__/parser.ts new file mode 100644 index 0000000..9921fce --- /dev/null +++ b/packages/cel/src/re2/__utils__/parser.ts @@ -0,0 +1,140 @@ +import { RE2Flags } from '../RE2Flags' +import { Regexp } from '../Regexp' +import { Unicode } from '../Unicode' + +const OP_NAMES = new Map([ + [Regexp.Op.NO_MATCH, 'no'], + [Regexp.Op.EMPTY_MATCH, 'emp'], + [Regexp.Op.LITERAL, 'lit'], + [Regexp.Op.CHAR_CLASS, 'cc'], + [Regexp.Op.ANY_CHAR_NOT_NL, 'dnl'], + [Regexp.Op.ANY_CHAR, 'dot'], + [Regexp.Op.BEGIN_LINE, 'bol'], + [Regexp.Op.END_LINE, 'eol'], + [Regexp.Op.BEGIN_TEXT, 'bot'], + [Regexp.Op.END_TEXT, 'eot'], + [Regexp.Op.WORD_BOUNDARY, 'wb'], + [Regexp.Op.NO_WORD_BOUNDARY, 'nwb'], + [Regexp.Op.CAPTURE, 'cap'], + [Regexp.Op.STAR, 'star'], + [Regexp.Op.PLUS, 'plus'], + [Regexp.Op.QUEST, 'que'], + [Regexp.Op.REPEAT, 'rep'], + [Regexp.Op.CONCAT, 'cat'], + [Regexp.Op.ALTERNATE, 'alt'] +]) + +export const dumpRegexp = (re: Regexp): string => { + let b = '' + if (!OP_NAMES.has(re.op)) { + b += `op${re.op}` + } else { + const name = OP_NAMES.get(re.op)! + + switch (re.op) { + case Regexp.Op.STAR: + case Regexp.Op.PLUS: + case Regexp.Op.QUEST: + case Regexp.Op.REPEAT: + if ((re.flags & RE2Flags.NON_GREEDY) !== 0) { + b += 'n' + } + b += name + break + case Regexp.Op.LITERAL: + if (re.runes.length > 1) { + b += 'str' + } else { + b += 'lit' + } + if ((re.flags & RE2Flags.FOLD_CASE) !== 0) { + for (let r of re.runes) { + if (Unicode.simpleFold(r) !== r) { + b += 'fold' + break + } + } + } + break + default: + b += name + break + } + } + b += '{' + switch (re.op) { + case Regexp.Op.END_TEXT: + if ((re.flags & RE2Flags.WAS_DOLLAR) === 0) { + b += '\\z' + } + break + case Regexp.Op.LITERAL: + for (let r of re.runes) { + b += String.fromCodePoint(r) + } + break + case Regexp.Op.CONCAT: + case Regexp.Op.ALTERNATE: + for (let sub of re.subs) { + b += dumpRegexp(sub) + } + break + case Regexp.Op.STAR: + case Regexp.Op.PLUS: + case Regexp.Op.QUEST: + b += dumpRegexp(re.subs[0]) + break + case Regexp.Op.REPEAT: + b += `${re.min},${re.max}` + b += ' ' + b += dumpRegexp(re.subs[0]) + break + case Regexp.Op.CAPTURE: + if (re.name !== null && re.name.length > 0) { + b += re.name + b += ':' + } + b += dumpRegexp(re.subs[0]) + break + case Regexp.Op.CHAR_CLASS: { + let sep = '' + for (let i = 0; i < re.runes.length; i += 2) { + b += sep + sep = ' ' + let lo = re.runes[i] + let hi = re.runes[i + 1] + if (lo === hi) { + b += `0x${lo.toString(16)}` + } else { + b += `0x${lo.toString(16)}-0x${hi.toString(16)}` + } + } + break + } + } + b += '}' + return b +} + +export const mkCharClass = (f: (r: number) => boolean): string => { + const re = new Regexp(Regexp.Op.CHAR_CLASS) + let runes: number[] = [] + let lo = -1 + + for (let i = 0; i <= Unicode.MAX_RUNE; i++) { + if (f(i)) { + if (lo < 0) { + lo = i + } + } else if (lo >= 0) { + runes = [...runes, lo, i - 1] + lo = -1 + } + } + if (lo >= 0) { + runes = [...runes, lo, Unicode.MAX_RUNE] + } + + re.runes = runes + return dumpRegexp(re) +} diff --git a/packages/cel/src/re2/__utils__/unicode.ts b/packages/cel/src/re2/__utils__/unicode.ts new file mode 100644 index 0000000..f862197 --- /dev/null +++ b/packages/cel/src/re2/__utils__/unicode.ts @@ -0,0 +1,14 @@ +const encoder = new TextEncoder() + +export const utf16IndicesToUtf8 = (idx16: number[], text: string): number[] => { + const idx8: number[] = new Array(idx16.length) + for (let i = 0; i < idx16.length; ++i) { + if (idx16[i] === -1) { + idx8[i] = -1 + } else { + const subText = text.substring(0, idx16[i]) + idx8[i] = encoder.encode(subText).length + } + } + return idx8 +} diff --git a/packages/cel/src/re2/exceptions.ts b/packages/cel/src/re2/exceptions.ts new file mode 100644 index 0000000..ef4eb6b --- /dev/null +++ b/packages/cel/src/re2/exceptions.ts @@ -0,0 +1,103 @@ +class RE2JSException extends Error { + /** @param {string} message */ + constructor(message: string) { + super(message) + this.name = 'RE2JSException' + } +} + +/** + * An exception thrown by the parser if the pattern was invalid. + */ +class RE2JSSyntaxException extends RE2JSException { + error: string + input: string | null + + /** + * @param {string} error + * @param {string|null} [input=null] + */ + constructor(error: string, input: string | null = null) { + let message = `error parsing regexp: ${error}` + if (input) { + message += `: \`${input}\`` + } + + super(message) + this.name = 'RE2JSSyntaxException' + this.message = message + /** @type {string} */ + this.error = error + /** @type {string|null} */ + this.input = input + } + + /** + * Retrieves the description of the error. + * @returns {string} + */ + getDescription(): string { + return this.error + } + + /** + * Retrieves the erroneous regular-expression pattern. + * @returns {string|null} + */ + getPattern(): string | null { + return this.input + } +} + +/** + * An exception thrown by the compiler + */ +class RE2JSCompileException extends RE2JSException { + /** @param {string} message */ + constructor(message: string) { + super(message) + this.name = 'RE2JSCompileException' + } +} + +/** + * An exception thrown by using groups + */ +class RE2JSGroupException extends RE2JSException { + /** @param {string} message */ + constructor(message: string) { + super(message) + this.name = 'RE2JSGroupException' + } +} + +/** + * An exception thrown by flags + */ +class RE2JSFlagsException extends RE2JSException { + /** @param {string} message */ + constructor(message: string) { + super(message) + this.name = 'RE2JSFlagsException' + } +} + +/** + * An exception thrown for internal engine errors, such as corrupted bytecodes. + */ +class RE2JSInternalException extends RE2JSException { + /** @param {string} message */ + constructor(message: string) { + super(message) + this.name = 'RE2JSInternalException' + } +} + +export { + RE2JSException, + RE2JSSyntaxException, + RE2JSCompileException, + RE2JSGroupException, + RE2JSFlagsException, + RE2JSInternalException +} diff --git a/packages/cel/src/re2/index.ts b/packages/cel/src/re2/index.ts new file mode 100644 index 0000000..4e76b8e --- /dev/null +++ b/packages/cel/src/re2/index.ts @@ -0,0 +1,223 @@ +import { RE2Flags } from './RE2Flags.js' +import { MachineInput } from './MachineInput.js' +import { RE2 } from './RE2.js' +import { Utils } from './Utils.js' +import { + RE2JSException, + RE2JSSyntaxException, + RE2JSCompileException, + RE2JSGroupException, + RE2JSFlagsException, + RE2JSInternalException +} from './exceptions.js' + +/** + * A compiled representation of an RE2 regular expression + * + * @class + */ +class RE2JS { + patternInput: string + flagsInput: number + re2Input: any + + /** + * Flag: case insensitive matching. + */ + static CASE_INSENSITIVE = 1 + /** + * Flag: dot ({@code .}) matches all characters, including newline. + */ + static DOTALL = 2 + /** + * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just + * beginning and end of input. + */ + static MULTILINE = 4 + /** + * Flag: Unicode groups (e.g. {@code \p{Greek}} ) will be syntax errors. + */ + static DISABLE_UNICODE_GROUPS = 8 + + /** + * Returns a literal pattern string for the specified string. + * + * @param {string} str The string to be literalized + * @returns {string} A literal string replacement + */ + static quote(str: string): string { + return Utils.quoteMeta(str) + } + + /** + * Helper: create new RE2JS with given regex and flags. + * @param {string} regex + * @param {number} [flags=0] + * @returns {RE2JS} + */ + static compile(regex: string, flags = 0): RE2JS { + let fregex = regex + if ((flags & RE2JS.CASE_INSENSITIVE) !== 0) { + fregex = `(?i)${fregex}` + } + if ((flags & RE2JS.DOTALL) !== 0) { + fregex = `(?s)${fregex}` + } + if ((flags & RE2JS.MULTILINE) !== 0) { + fregex = `(?m)${fregex}` + } + if ( + (flags & + ~( + RE2JS.MULTILINE | + RE2JS.DOTALL | + RE2JS.CASE_INSENSITIVE | + RE2JS.DISABLE_UNICODE_GROUPS + )) !== + 0 + ) { + throw new RE2JSFlagsException( + 'Flags should only be a combination of MULTILINE, DOTALL, CASE_INSENSITIVE, DISABLE_UNICODE_GROUPS' + ) + } + + let re2Flags = RE2Flags.PERL + if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) { + re2Flags &= ~RE2Flags.UNICODE_GROUPS + } + + const p = new RE2JS(regex, flags) + p.re2Input = RE2.compileImpl(fregex, re2Flags) + return p + } + + /** + * Matches a string against a regular expression. + * + * @param {string} regex the regular expression + * @param {string} input the input + * @returns {boolean} true if the regular expression matches the entire input + * @throws RE2JSSyntaxException if the regular expression is malformed + */ + static matches(regex: string, input: string): boolean { + return RE2JS.compile(regex).testExact(input) + } + + /** + * This is visible for testing. + * @private + */ + static initTest(pattern: string, flags: number, re2: any): RE2JS { + if (pattern == null) { + throw new Error('pattern is null') + } + if (re2 == null) { + throw new Error('re2 is null') + } + const p = new RE2JS(pattern, flags) + p.re2Input = re2 + return p + } + + /** + * @param {string} pattern + * @param {number} flags + */ + constructor(pattern: string, flags: number) { + this.patternInput = pattern + this.flagsInput = flags + } + + /** + * Releases memory used by internal caches associated with this pattern. + */ + reset(): void { + this.re2Input.reset() + } + + /** + * Returns the flags used in the constructor. + * @returns {number} + */ + flags(): number { + return this.flagsInput + } + + /** + * Returns the pattern used in the constructor. + * @returns {string} + */ + pattern(): string { + return this.patternInput + } + + re2(): any { + return this.re2Input + } + + /** + * Matches a string against a regular expression. + * + * @param {string} input the input + * @returns {boolean} true if the regular expression matches the entire input + */ + matches(input: string): boolean { + return this.testExact(input) + } + + /** + * Tests whether the regular expression matches any part of the input string. + * + * @param {string} input - The input string to test against. + * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise. + */ + test(input: string): boolean { + return this.re2Input.match(input) + } + + /** + * Tests whether the regular expression matches the ENTIRE input string. + * + * @param {string} input - The input string to test against. + * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise. + */ + testExact(input: string): boolean { + return ( + this.re2Input.executeEngine(MachineInput.fromUTF16(input), 0, RE2Flags.ANCHOR_BOTH, 0) !== + null + ) + } + + /** + * @returns {string} + */ + toString(): string { + return this.patternInput + } + + /** + * Returns the number of capturing groups in this matcher's pattern. + * @returns {number} + */ + groupCount(): number { + return this.re2Input.numberOfCapturingGroups() + } + + /** + * Return a map of the capturing groups in this matcher's pattern. + * @returns {Record} + */ + namedGroups(): Record { + return this.re2Input.namedGroups + } +} + +export { + RE2JS, + RE2JSException, + RE2JSSyntaxException, + RE2JSCompileException, + RE2JSGroupException, + RE2JSFlagsException, + RE2JSInternalException, +} diff --git a/packages/cel/src/std/logic.ts b/packages/cel/src/std/logic.ts index bfca5a0..122926b 100644 --- a/packages/cel/src/std/logic.ts +++ b/packages/cel/src/std/logic.ts @@ -15,17 +15,18 @@ import * as opc from "../gen/dev/cel/expr/operator_const.js"; import * as olc from "../gen/dev/cel/expr/overload_const.js"; import { - CelScalar, - DURATION, - listType, - mapType, - TIMESTAMP, - type CelValue, + CelScalar, + DURATION, + listType, + mapType, + TIMESTAMP, + type CelValue, } from "../type.js"; -import { equals } from "../equals.js"; -import { celMethod, celFunc } from "../func.js"; -import type { CelList } from "../list.js"; -import type { CelMap } from "../map.js"; +import {equals} from "../equals.js"; +import {celMethod, celFunc} from "../func.js"; +import type {CelList} from "../list.js"; +import type {CelMap} from "../map.js"; +import {RE2JS} from "../re2/index.js"; /** * Patterns that are supported in ECMAScript RE and not in @@ -35,194 +36,210 @@ import type { CelMap } from "../map.js"; * RE2: https://github.com/google/re2/wiki/syntax */ const invalidPatterns = [ - /\\[1-9]/, // backreference eg: \1 - /\\k<.>/, // backreference eg: \k - /\(\?\=/, // lookahead eg: Jack(?=Sprat) - /\(\?\!/, // negative lookahead eg: Jack(?!Sprat) - /\(\?\<\=/, // lookbehind eg: (?<=Sprat)Jack - /\(\?\<\!/, // negative lookbehind eg: (?/, // backreference eg: \k + /\(\?\=/, // lookahead eg: Jack(?=Sprat) + /\(\?\!/, // negative lookahead eg: Jack(?!Sprat) + /\(\?\<\=/, // lookbehind eg: (?<=Sprat)Jack + /\(\?\<\!/, // negative lookbehind eg: (?[ims\-]+)\)/); +const flagMappings = new Map(). + set("i", RE2JS.CASE_INSENSITIVE). + set("m", RE2JS.MULTILINE). + set("s", RE2JS.DOTALL); + export function matches(this: string, pattern: string): boolean { - for (const invalidPattern of invalidPatterns) { - if (invalidPattern.test(pattern)) { - throw new Error( - `Error evaluating pattern ${pattern}, invalid RE2 syntax`, - ); + + // can probably delete this since the RE2 engine will already reject them, but keep for now + for (const invalidPattern of invalidPatterns) { + if (invalidPattern.test(pattern)) { + throw new Error( + `Error evaluating pattern ${pattern}, invalid RE2 syntax`, + ); + } } - } - // CEL use RE2 syntax which is a subset of Ecmascript RE except for - // the flags and the ability to change the flags mid-sequence. - // - // The conformance tests use flags at the very beginning of the sequence, which - // is likely the most common place where this rare feature will be used. - // - // Instead of importing an RE2 engine to be able to support this niche, we - // can instead just check for the flags at the very beginning and apply them. - // - // Unsupported flags and flags mid-sequence will fail with to compile the regex. - // - // Users can choose to override this function and provide an RE2 engine if they really - // need to. - let flags = ""; - const flagMatches = pattern.match(flagPattern); - if (flagMatches) { - for (let flag of flagMatches?.groups?.flags ?? "") { - if (flag == "-") { - break; - } - flags += flag; + // CEL use RE2 syntax which is a subset of Ecmascript RE except for + // the flags and the ability to change the flags mid-sequence. + // + // The conformance tests use flags at the very beginning of the sequence, which + // is likely the most common place where this rare feature will be used. + // + // Instead of importing an RE2 engine to be able to support this niche, we + // can instead just check for the flags at the very beginning and apply them. + // + // Unsupported flags and flags mid-sequence will fail with to compile the regex. + // + // Users can choose to override this function and provide an RE2 engine if they really + // need to. + let flagVal: number = 0; + const flagMatches = pattern.match(flagPattern); + if (flagMatches) { + for (let flag of flagMatches?.groups?.flags ?? "") { + if (flag == "-") { + break; + } + flagVal |= flagMappings.get(flag) ?? 0; + } + pattern = pattern.substring(flagMatches[0].length); } - pattern = pattern.substring(flagMatches[0].length); - } - const re = new RegExp(pattern, flags); - return re.test(this); + const re: RE2JS = RE2JS.compile(pattern, flagVal); + //const re = new RegExp(pattern, flags); + return re.test(this); } function compareDuration( - lhs: CelValue, - rhs: CelValue, + lhs: CelValue, + rhs: CelValue, ) { - const cmp = lhs.message.seconds - rhs.message.seconds; - if (cmp == 0n) { - return lhs.message.nanos - rhs.message.nanos; - } - return cmp < 0n ? -1 : 1; + const cmp = lhs.message.seconds - rhs.message.seconds; + if (cmp == 0n) { + return lhs.message.nanos - rhs.message.nanos; + } + return cmp < 0n ? -1 : 1; } function compareTimestamp( - lhs: CelValue, - rhs: CelValue, + lhs: CelValue, + rhs: CelValue, ) { - const cmp = lhs.message.seconds - rhs.message.seconds; - if (cmp == 0n) { - return lhs.message.nanos - rhs.message.nanos; - } - return cmp < 0n ? -1 : 1; + const cmp = lhs.message.seconds - rhs.message.seconds; + if (cmp == 0n) { + return lhs.message.nanos - rhs.message.nanos; + } + return cmp < 0n ? -1 : 1; } function compareBytes(lhs: Uint8Array, rhs: Uint8Array): number { - const minLen = Math.min(lhs.length, rhs.length); - for (let i = 0; i < minLen; i++) { - if (lhs[i] < rhs[i]) { - return -1; - } - if (lhs[i] > rhs[i]) { - return 1; + const minLen = Math.min(lhs.length, rhs.length); + for (let i = 0; i < minLen; i++) { + if (lhs[i] < rhs[i]) { + return -1; + } + if (lhs[i] > rhs[i]) { + return 1; + } } - } - return lhs.length - rhs.length; + return lhs.length - rhs.length; } function inList(value: CelValue, list: CelList) { - for (const v of list) { - if (equals(v, value)) return true; - } - return false; + for (const v of list) { + if (equals(v, value)) return true; + } + return false; } function inMap[0]>(value: T, map: CelMap) { - return map.has(value); + return map.has(value); } -const { BOOL, BYTES, DOUBLE, DYN, INT, STRING, UINT } = CelScalar; +const {BOOL, BYTES, DOUBLE, DYN, INT, STRING, UINT} = CelScalar; const LIST = listType(CelScalar.DYN); const MAP = mapType(CelScalar.DYN, CelScalar.DYN); // biome-ignore format: table export default [ - // ! - celFunc(opc.LOGICAL_NOT, [BOOL], BOOL, (x) => !x), - // = - celFunc(opc.EQUALS, [DYN, DYN], BOOL, equals), - celFunc(opc.NOT_EQUALS, [DYN, DYN], BOOL, (l, r) => !equals(l, r)), - // < - celFunc(opc.LESS, [BOOL, BOOL], BOOL, (l, r) => l < r), - celFunc(opc.LESS, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) < 0), - celFunc(opc.LESS, [DOUBLE, DOUBLE], BOOL, (l, r) => l < r), - celFunc(opc.LESS, [STRING, STRING], BOOL, (l, r) => l < r), - celFunc(opc.LESS, [INT, INT], BOOL, (l, r) => l < r), - celFunc(opc.LESS, [INT, UINT], BOOL, (l, r) => l < r.value), - celFunc(opc.LESS, [UINT, INT], BOOL, (l, r) => l.value < r), - celFunc(opc.LESS, [UINT, UINT], BOOL, (l, r) => l.value < r.value), - // TODO investigate: ECMAScript relational operators support mixed bigint/number operands, - // but removing the coercion to number here fails the conformance test "not_lt_dyn_int_big_lossy_double" - celFunc(opc.LESS, [INT, DOUBLE], BOOL, (l, r) => Number(l) < r), - celFunc(opc.LESS, [DOUBLE, INT], BOOL, (l, r) => l < Number(r)), - celFunc(opc.LESS, [DOUBLE, UINT], BOOL, (l, r) => l < Number(r.value)), - celFunc(opc.LESS, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) < r), - celFunc(opc.LESS, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) < 0), - celFunc(opc.LESS, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) < 0), - // <= - celFunc(opc.LESS_EQUALS, [BOOL, BOOL], BOOL, (l, r) => l <= r), - celFunc(opc.LESS_EQUALS, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) <= 0), - celFunc(opc.LESS_EQUALS, [DOUBLE, DOUBLE], BOOL, (l, r) => l <= r), - celFunc(opc.LESS_EQUALS, [STRING, STRING], BOOL, (l, r) => l <= r), - celFunc(opc.LESS_EQUALS, [INT, INT], BOOL, (l, r) => l <= r), - celFunc(opc.LESS_EQUALS, [INT, UINT], BOOL, (l, r) => l <= r.value), - celFunc(opc.LESS_EQUALS, [UINT, INT], BOOL, (l, r) => l.value <= r), - celFunc(opc.LESS_EQUALS, [UINT, UINT], BOOL, (l, r) => l.value <= r.value), - celFunc(opc.LESS_EQUALS, [INT, DOUBLE], BOOL, (l, r) => Number(l) <= r), - celFunc(opc.LESS_EQUALS, [DOUBLE, INT], BOOL, (l, r) => l <= Number(r)), - celFunc(opc.LESS_EQUALS, [DOUBLE, UINT], BOOL, (l, r) => l <= Number(r.value)), - celFunc(opc.LESS_EQUALS, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) <= r), - celFunc(opc.LESS_EQUALS, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) <= 0), - celFunc(opc.LESS_EQUALS, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) <= 0), - // > - celFunc(opc.GREATER, [BOOL, BOOL], BOOL, (l, r) => l > r), - celFunc(opc.GREATER, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) > 0), - celFunc(opc.GREATER, [DOUBLE, DOUBLE], BOOL, (l, r) => l > r), - celFunc(opc.GREATER, [STRING, STRING], BOOL, (l, r) => l > r), - celFunc(opc.GREATER, [INT, INT], BOOL, (l, r) => l > r), - celFunc(opc.GREATER, [INT, UINT], BOOL, (l, r) => l > r.value), - celFunc(opc.GREATER, [UINT, INT], BOOL, (l, r) => l.value > r), - celFunc(opc.GREATER, [UINT, UINT], BOOL, (l, r) => l.value > r.value), - celFunc(opc.GREATER, [INT, DOUBLE], BOOL, (l, r) => Number(l) > r), - celFunc(opc.GREATER, [DOUBLE, INT], BOOL, (l, r) => l > Number(r)), - celFunc(opc.GREATER, [DOUBLE, UINT], BOOL, (l, r) => l > Number(r.value)), - celFunc(opc.GREATER, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) > r), - celFunc(opc.GREATER, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) > 0), - celFunc(opc.GREATER, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) > 0), - // >= - celFunc(opc.GREATER_EQUALS, [BOOL, BOOL], BOOL, (l, r) => l >= r), - celFunc(opc.GREATER_EQUALS, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) >= 0), - celFunc(opc.GREATER_EQUALS, [DOUBLE, DOUBLE], BOOL, (l, r) => l >= r), - celFunc(opc.GREATER_EQUALS, [STRING, STRING], BOOL, (l, r) => l >= r), - celFunc(opc.GREATER_EQUALS, [INT, INT], BOOL, (l, r) => l >= r), - celFunc(opc.GREATER_EQUALS, [INT, UINT], BOOL, (l, r) => l >= r.value), - celFunc(opc.GREATER_EQUALS, [UINT, INT], BOOL, (l, r) => l.value >= r), - celFunc(opc.GREATER_EQUALS, [UINT, UINT], BOOL, (l, r) => l.value >= r.value), - celFunc(opc.GREATER_EQUALS, [INT, DOUBLE], BOOL, (l, r) => Number(l) >= r), - celFunc(opc.GREATER_EQUALS, [DOUBLE, INT], BOOL, (l, r) => l >= Number(r)), - celFunc(opc.GREATER_EQUALS, [DOUBLE, UINT], BOOL, (l, r) => l >= Number(r.value)), - celFunc(opc.GREATER_EQUALS, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) >= r), - celFunc(opc.GREATER_EQUALS, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) >= 0), - celFunc(opc.GREATER_EQUALS, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) >= 0), - // size - celFunc(olc.SIZE, [BYTES], INT, (x) => BigInt(x.length)), - celFunc(olc.SIZE, [LIST], INT, (x) => BigInt(x.size)), - celFunc(olc.SIZE, [STRING], INT, (x) => BigInt([...x].length)), - celFunc(olc.SIZE, [MAP], INT, (x) => BigInt(x.size)), - celMethod(olc.SIZE, BYTES, [], INT, function () {return BigInt(this.length)}), - celMethod(olc.SIZE, LIST, [], INT, function () {return BigInt(this.size)}), - celMethod(olc.SIZE, STRING, [], INT, function () {return BigInt([...this].length)}), - celMethod(olc.SIZE, MAP, [], INT, function () {return BigInt(this.size)}), - // in - celFunc(opc.IN, [DYN, LIST], BOOL, inList), - celFunc(opc.IN, [STRING, MAP], BOOL, inMap), - celFunc(opc.IN, [DOUBLE, MAP], BOOL, inMap), - celFunc(opc.IN, [INT, MAP], BOOL, inMap), - celFunc(opc.IN, [BOOL, MAP], BOOL, inMap), - celFunc(opc.IN, [UINT, MAP], BOOL, inMap), - // string.* - celMethod(olc.CONTAINS, STRING, [STRING], BOOL, String.prototype.includes), - celMethod(olc.ENDS_WITH, STRING, [STRING], BOOL, String.prototype.endsWith), - celMethod(olc.STARTS_WITH, STRING, [STRING], BOOL, String.prototype.startsWith), - celMethod(olc.MATCHES, STRING, [STRING], BOOL, matches), + // ! + celFunc(opc.LOGICAL_NOT, [BOOL], BOOL, (x) => !x), + // = + celFunc(opc.EQUALS, [DYN, DYN], BOOL, equals), + celFunc(opc.NOT_EQUALS, [DYN, DYN], BOOL, (l, r) => !equals(l, r)), + // < + celFunc(opc.LESS, [BOOL, BOOL], BOOL, (l, r) => l < r), + celFunc(opc.LESS, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) < 0), + celFunc(opc.LESS, [DOUBLE, DOUBLE], BOOL, (l, r) => l < r), + celFunc(opc.LESS, [STRING, STRING], BOOL, (l, r) => l < r), + celFunc(opc.LESS, [INT, INT], BOOL, (l, r) => l < r), + celFunc(opc.LESS, [INT, UINT], BOOL, (l, r) => l < r.value), + celFunc(opc.LESS, [UINT, INT], BOOL, (l, r) => l.value < r), + celFunc(opc.LESS, [UINT, UINT], BOOL, (l, r) => l.value < r.value), + // TODO investigate: ECMAScript relational operators support mixed bigint/number operands, + // but removing the coercion to number here fails the conformance test "not_lt_dyn_int_big_lossy_double" + celFunc(opc.LESS, [INT, DOUBLE], BOOL, (l, r) => Number(l) < r), + celFunc(opc.LESS, [DOUBLE, INT], BOOL, (l, r) => l < Number(r)), + celFunc(opc.LESS, [DOUBLE, UINT], BOOL, (l, r) => l < Number(r.value)), + celFunc(opc.LESS, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) < r), + celFunc(opc.LESS, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) < 0), + celFunc(opc.LESS, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) < 0), + // <= + celFunc(opc.LESS_EQUALS, [BOOL, BOOL], BOOL, (l, r) => l <= r), + celFunc(opc.LESS_EQUALS, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) <= 0), + celFunc(opc.LESS_EQUALS, [DOUBLE, DOUBLE], BOOL, (l, r) => l <= r), + celFunc(opc.LESS_EQUALS, [STRING, STRING], BOOL, (l, r) => l <= r), + celFunc(opc.LESS_EQUALS, [INT, INT], BOOL, (l, r) => l <= r), + celFunc(opc.LESS_EQUALS, [INT, UINT], BOOL, (l, r) => l <= r.value), + celFunc(opc.LESS_EQUALS, [UINT, INT], BOOL, (l, r) => l.value <= r), + celFunc(opc.LESS_EQUALS, [UINT, UINT], BOOL, (l, r) => l.value <= r.value), + celFunc(opc.LESS_EQUALS, [INT, DOUBLE], BOOL, (l, r) => Number(l) <= r), + celFunc(opc.LESS_EQUALS, [DOUBLE, INT], BOOL, (l, r) => l <= Number(r)), + celFunc(opc.LESS_EQUALS, [DOUBLE, UINT], BOOL, (l, r) => l <= Number(r.value)), + celFunc(opc.LESS_EQUALS, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) <= r), + celFunc(opc.LESS_EQUALS, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) <= 0), + celFunc(opc.LESS_EQUALS, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) <= 0), + // > + celFunc(opc.GREATER, [BOOL, BOOL], BOOL, (l, r) => l > r), + celFunc(opc.GREATER, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) > 0), + celFunc(opc.GREATER, [DOUBLE, DOUBLE], BOOL, (l, r) => l > r), + celFunc(opc.GREATER, [STRING, STRING], BOOL, (l, r) => l > r), + celFunc(opc.GREATER, [INT, INT], BOOL, (l, r) => l > r), + celFunc(opc.GREATER, [INT, UINT], BOOL, (l, r) => l > r.value), + celFunc(opc.GREATER, [UINT, INT], BOOL, (l, r) => l.value > r), + celFunc(opc.GREATER, [UINT, UINT], BOOL, (l, r) => l.value > r.value), + celFunc(opc.GREATER, [INT, DOUBLE], BOOL, (l, r) => Number(l) > r), + celFunc(opc.GREATER, [DOUBLE, INT], BOOL, (l, r) => l > Number(r)), + celFunc(opc.GREATER, [DOUBLE, UINT], BOOL, (l, r) => l > Number(r.value)), + celFunc(opc.GREATER, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) > r), + celFunc(opc.GREATER, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) > 0), + celFunc(opc.GREATER, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) > 0), + // >= + celFunc(opc.GREATER_EQUALS, [BOOL, BOOL], BOOL, (l, r) => l >= r), + celFunc(opc.GREATER_EQUALS, [BYTES, BYTES], BOOL, (l, r) => compareBytes(l, r) >= 0), + celFunc(opc.GREATER_EQUALS, [DOUBLE, DOUBLE], BOOL, (l, r) => l >= r), + celFunc(opc.GREATER_EQUALS, [STRING, STRING], BOOL, (l, r) => l >= r), + celFunc(opc.GREATER_EQUALS, [INT, INT], BOOL, (l, r) => l >= r), + celFunc(opc.GREATER_EQUALS, [INT, UINT], BOOL, (l, r) => l >= r.value), + celFunc(opc.GREATER_EQUALS, [UINT, INT], BOOL, (l, r) => l.value >= r), + celFunc(opc.GREATER_EQUALS, [UINT, UINT], BOOL, (l, r) => l.value >= r.value), + celFunc(opc.GREATER_EQUALS, [INT, DOUBLE], BOOL, (l, r) => Number(l) >= r), + celFunc(opc.GREATER_EQUALS, [DOUBLE, INT], BOOL, (l, r) => l >= Number(r)), + celFunc(opc.GREATER_EQUALS, [DOUBLE, UINT], BOOL, (l, r) => l >= Number(r.value)), + celFunc(opc.GREATER_EQUALS, [UINT, DOUBLE], BOOL, (l, r) => Number(l.value) >= r), + celFunc(opc.GREATER_EQUALS, [DURATION, DURATION], BOOL, (l, r) => compareDuration(l, r) >= 0), + celFunc(opc.GREATER_EQUALS, [TIMESTAMP, TIMESTAMP], BOOL, (l, r) => compareTimestamp(l, r) >= 0), + // size + celFunc(olc.SIZE, [BYTES], INT, (x) => BigInt(x.length)), + celFunc(olc.SIZE, [LIST], INT, (x) => BigInt(x.size)), + celFunc(olc.SIZE, [STRING], INT, (x) => BigInt([...x].length)), + celFunc(olc.SIZE, [MAP], INT, (x) => BigInt(x.size)), + celMethod(olc.SIZE, BYTES, [], INT, function () { + return BigInt(this.length) + }), + celMethod(olc.SIZE, LIST, [], INT, function () { + return BigInt(this.size) + }), + celMethod(olc.SIZE, STRING, [], INT, function () { + return BigInt([...this].length) + }), + celMethod(olc.SIZE, MAP, [], INT, function () { + return BigInt(this.size) + }), + // in + celFunc(opc.IN, [DYN, LIST], BOOL, inList), + celFunc(opc.IN, [STRING, MAP], BOOL, inMap), + celFunc(opc.IN, [DOUBLE, MAP], BOOL, inMap), + celFunc(opc.IN, [INT, MAP], BOOL, inMap), + celFunc(opc.IN, [BOOL, MAP], BOOL, inMap), + celFunc(opc.IN, [UINT, MAP], BOOL, inMap), + // string.* + celMethod(olc.CONTAINS, STRING, [STRING], BOOL, String.prototype.includes), + celMethod(olc.ENDS_WITH, STRING, [STRING], BOOL, String.prototype.endsWith), + celMethod(olc.STARTS_WITH, STRING, [STRING], BOOL, String.prototype.startsWith), + celMethod(olc.MATCHES, STRING, [STRING], BOOL, matches), ]; diff --git a/packages/cel/src/testing.ts b/packages/cel/src/testing.ts index 817a19f..7d1505b 100644 --- a/packages/cel/src/testing.ts +++ b/packages/cel/src/testing.ts @@ -59,7 +59,7 @@ import { KindAdorner, SemanticAdorner, toDebugString, -} from "@bufbuild/cel-spec/testdata/to-debug-string.js"; +} from "../../cel-spec/dist/cjs/testdata/to-debug-string.js"; import { check, outputType } from "./check.js"; import type { SimpleTest } from "@bufbuild/cel-spec/cel/expr/conformance/test/simple_pb.js"; import { protoTypeToCelType } from "./checker.js"; diff --git a/scripts/codepointRange.js b/scripts/codepointRange.js new file mode 100644 index 0000000..e41cdfb --- /dev/null +++ b/scripts/codepointRange.js @@ -0,0 +1,42 @@ +class CodepointRange { + constructor() { + this.builder = [] + this.setStart = null + this.setStride = null + this.lastInSet = null + } + + add(codepoint) { + if (this.setStart === null) { + this.setStart = codepoint + } else if (this.setStride === null) { + this.setStride = codepoint - this.lastInSet + } else if (codepoint - this.lastInSet !== this.setStride) { + // gotta start a new set + this.builder.push([this.setStart, this.lastInSet, this.setStride]) + this.setStart = codepoint + this.setStride = null + } + this.lastInSet = codepoint + } + + addAll(codepoints) { + const sortedCodepoints = Array.from(codepoints).sort((a, b) => a - b) + for (const i of sortedCodepoints) { + this.add(i) + } + } + + finish() { + if (this.setStart !== null) { + this.builder.push([ + this.setStart, + this.lastInSet, + this.setStride === null ? 1 : this.setStride + ]) + } + return this.builder + } +} + +export { CodepointRange } diff --git a/scripts/genUnicodeTable.js b/scripts/genUnicodeTable.js new file mode 100644 index 0000000..519ea7b --- /dev/null +++ b/scripts/genUnicodeTable.js @@ -0,0 +1,493 @@ +import { CodepointRange } from './codepointRange.js' +import unicode16 from '@unicode/unicode-16.0.0' +import unicode15 from '@unicode/unicode-15.0.0' +import CommonCaseFolding from '@unicode/unicode-16.0.0/Case_Folding/C/code-points.js' +import SimpleCaseFolding from '@unicode/unicode-16.0.0/Case_Folding/S/code-points.js' +import unicodePropertyValueAliases from 'unicode-property-value-aliases' + +const MAX_CODE_POINT = 0x10ffff +const SKIP_CATEGORIES = ['cntrl', 'Combining_Mark', 'digit', 'punct'] +const aliasesToNames = unicodePropertyValueAliases.get('General_Category') + +// --- CASE_ORBIT (reduced table of non-derivable fold relationships) --- + +const generateCaseFoldOrbits = () => { + let orbits = new Map() + for (let i = 0; i < MAX_CODE_POINT; i++) { + if (!CommonCaseFolding.has(i) && !SimpleCaseFolding.has(i)) { + continue + } + + const f = CommonCaseFolding.get(i) || SimpleCaseFolding.get(i) + let orbit = orbits.get(f) || new Set() + orbit.add(f) + orbit.add(i) + orbits.set(f, orbit) + } + + for (let i = 0; i < MAX_CODE_POINT; i++) { + if (!orbits.has(i)) continue + if (orbits.get(i).size === 1) orbits.delete(i) + } + + const finalResult = new Map() + for (let [key, value] of orbits) { + let orbitWithKey = new Set(value) + orbitWithKey.add(key) + orbitWithKey = Array.from(orbitWithKey).sort((a, b) => a - b) + let a = orbitWithKey[0] + for (let i of orbitWithKey.slice(1)) { + finalResult.set(a, i) + a = i + } + finalResult.set(orbitWithKey[orbitWithKey.length - 1], orbitWithKey[0]) + } + return finalResult +} + +const sortedOrbits = generateCaseFoldOrbits() + +// rawSimpleFold mirrors the runtime Unicode.simpleFold fallback: raw +// String.prototype.toLowerCase/toUpperCase with a length check to reject +// multi-char expansions (e.g. ß→SS). Used to reduce CASE_ORBIT to only +// entries where raw native disagrees with the correct fold. +const rawSimpleFold = (r) => { + const s = String.fromCodePoint(r) + const lower = s.toLowerCase() + if (lower.length === s.length) { + const lowerCp = lower.codePointAt(0) + if (lowerCp !== r) return lowerCp + } + const upper = s.toUpperCase() + if (upper.length === s.length) { + const upperCp = upper.codePointAt(0) + if (upperCp !== r) return upperCp + } + return r +} + +const buildReducedOrbit = () => { + const reduced = new Map() + for (const [r, v] of sortedOrbits) { + if (rawSimpleFold(r) !== v) reduced.set(r, v) + } + for (let r = 0; r < MAX_CODE_POINT; r++) { + if (r >= 0xd800 && r <= 0xdfff) continue + if (sortedOrbits.has(r)) continue + if (rawSimpleFold(r) !== r) reduced.set(r, r) + } + return reduced +} + +const reducedOrbit = buildReducedOrbit() + +// --- Loaders --- + +const loadCodePoints = async (pkg, type, name) => { + try { + const { default: codePoints } = await import(`${pkg}/${type}/${name}/code-points.js`) + return new Set(codePoints) + } catch (_e) { + return null + } +} + +const computeRanges = (codepoints) => { + if (codepoints.size === 0) return [] + const gen = new CodepointRange() + gen.addAll(Array.from(codepoints).sort((a, b) => a - b)) + return gen.finish() +} + +const setDiff = (a, b) => { + if (!b) return new Set(a) + const out = new Set() + for (const x of a) if (!b.has(x)) out.add(x) + return out +} + +// --- VLQ --- + +const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-' + +const encodeVLQ = (value) => { + let res = '' + do { + let digit = value & 0x1f + value >>>= 5 + if (value > 0) digit |= 0x20 + res += B64[digit] + } while (value > 0) + return res +} + +const encodeRanges = (ranges) => { + if (ranges.length === 0) return { encoded: '', stride1: true, empty: true } + let encoded = '' + let current = 0 + const stride1 = ranges.every((r) => r[2] === 1) + for (const r of ranges) { + encoded += encodeVLQ(r[0] - current) + encoded += encodeVLQ(r[1] - r[0]) + if (!stride1) encoded += encodeVLQ(r[2]) + current = r[1] + } + return { encoded, stride1, empty: false } +} + +// --- Delta computation --- + +const deltaCatLines = [] +const deltaScrLines = [] +const newScriptLines = [] +const stableCategoryNames = [] +const stableScriptNames = [] +const newScriptNames = [] + +for (const [alias, name] of aliasesToNames.entries()) { + if (SKIP_CATEGORIES.includes(alias)) continue + const cp16 = await loadCodePoints('@unicode/unicode-16.0.0', 'General_Category', name) + if (!cp16) continue + const cp15 = await loadCodePoints('@unicode/unicode-15.0.0', 'General_Category', name) + stableCategoryNames.push(alias) + const delta = setDiff(cp16, cp15) + if (delta.size > 0) { + const ranges = computeRanges(delta) + const enc = encodeRanges(ranges) + deltaCatLines.push(` '${alias}': () => decodeRanges('${enc.encoded}', ${enc.stride1}),`) + } +} + +for (const name of unicode16['Script']) { + const cp16 = await loadCodePoints('@unicode/unicode-16.0.0', 'Script', name) + if (!cp16) continue + const cp15 = await loadCodePoints('@unicode/unicode-15.0.0', 'Script', name) + if (cp15) { + stableScriptNames.push(name) + const delta = setDiff(cp16, cp15) + if (delta.size > 0) { + const ranges = computeRanges(delta) + const enc = encodeRanges(ranges) + deltaScrLines.push(` '${name}': () => decodeRanges('${enc.encoded}', ${enc.stride1}),`) + } + } else { + newScriptNames.push(name) + const ranges = computeRanges(cp16) + const enc = encodeRanges(ranges) + newScriptLines.push( + ` '${name}': () => new UnicodeRangeTable(decodeRanges('${enc.encoded}', ${enc.stride1})),` + ) + } +} + +// --- CASE_ORBIT encoding --- + +const caseOrbitEntries = Array.from(reducedOrbit.entries()).sort((a, b) => a[0] - b[0]) +let orbitEnc = '' +let curr = 0 +for (const [k, v] of caseOrbitEntries) { + orbitEnc += encodeVLQ(k - curr) + orbitEnc += encodeVLQ(v) + curr = k +} + +// --- Emit UnicodeTables.ts --- + +const code = [ + '// GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT.', + '// yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts', + '', + "import { UnicodeRangeTable } from './UnicodeRangeTable'", + '', + 'let _B64_MAP: Uint8Array | null = null', + 'const getB64Map = (): Uint8Array => {', + ' if (!_B64_MAP) {', + ' _B64_MAP = new Uint8Array(256)', + ` const b = '${B64}'`, + ' for (let i = 0; i < 64; i++) {', + ' _B64_MAP[b.charCodeAt(i)] = i', + ' }', + ' }', + ' return _B64_MAP', + '}', + '', + 'const decodeVLQ = (str: string): number[] => {', + ' const b64 = getB64Map()', + ' const res: number[] = []', + ' let value = 0, shift = 0', + ' for (let i = 0; i < str.length; i++) {', + ' const digit = b64[str.charCodeAt(i)]', + ' value |= (digit & 0x1f) << shift', + ' if ((digit & 0x20) === 0) {', + ' res.push(value)', + ' value = 0', + ' shift = 0', + ' } else {', + ' shift += 5', + ' }', + ' }', + ' return res', + '}', + '', + 'const decodeRanges = (str: string, isStride1: boolean): Uint32Array => {', + ' if (str.length === 0) return new Uint32Array(0)', + ' const res = decodeVLQ(str)', + ' const numRanges = isStride1 ? res.length / 2 : res.length / 3', + ' const out = new Uint32Array(numRanges * 3)', + ' let current = 0, resIdx = 0', + ' for (let i = 0; i < numRanges; i++) {', + ' current += res[resIdx++]', + ' out[i * 3] = current', + ' current += res[resIdx++]', + ' out[i * 3 + 1] = current', + ' out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++]', + ' }', + ' return out', + '}', + '', + 'const decodeOrbit = (str: string): Map => {', + ' const res = decodeVLQ(str)', + ' const map = new Map()', + ' let currentKey = 0', + ' for (let i = 0; i < res.length; i += 2) {', + ' currentKey += res[i]', + ' map.set(currentKey, res[i + 1])', + ' }', + ' return map', + '}', + '', + '// Merges two stride-encoded UnicodeRangeTables. Expands any stride>1', + '// ranges to individual codepoints, then coalesces contiguous runs.', + 'const mergeRanges = (a: Uint32Array, b: Uint32Array): Uint32Array => {', + ' if (b.length === 0) return a', + ' if (a.length === 0) return b', + ' const points: [number, number][] = []', + ' const push = (arr: Uint32Array): void => {', + ' for (let i = 0; i < arr.length; i += 3) {', + ' const lo = arr[i], hi = arr[i + 1], stride = arr[i + 2]', + ' if (stride === 1) {', + ' points.push([lo, hi])', + ' } else {', + ' for (let cp = lo; cp <= hi; cp += stride) points.push([cp, cp])', + ' }', + ' }', + ' }', + ' push(a)', + ' push(b)', + ' points.sort((x, y) => x[0] - y[0])', + ' const merged: [number, number][] = []', + ' for (const [lo, hi] of points) {', + ' const last = merged[merged.length - 1]', + ' if (last && last[1] + 1 >= lo) {', + ' if (hi > last[1]) last[1] = hi', + ' } else {', + ' merged.push([lo, hi])', + ' }', + ' }', + ' const out = new Uint32Array(merged.length * 3)', + ' for (let i = 0; i < merged.length; i++) {', + ' out[i * 3] = merged[i][0]', + ' out[i * 3 + 1] = merged[i][1]', + ' out[i * 3 + 2] = 1', + ' }', + ' return out', + '}', + '', + '// Sweeps the codepoint space using a platform property-escape regex and', + '// returns stride-1 ranges. Surrogates are included — String.fromCodePoint', + '// returns the lone surrogate char and platform regex matches \\p{Cs} on it.', + 'const sweepPlatform = (pattern: string): Uint32Array => {', + ' const re = new RegExp(pattern, "u")', + ' const ranges: number[] = []', + ' let start = -1', + ' for (let cp = 0; cp <= 0x10ffff; cp++) {', + ' if (re.test(String.fromCodePoint(cp))) {', + ' if (start < 0) start = cp', + ' } else if (start >= 0) {', + ' ranges.push(start, cp - 1, 1)', + ' start = -1', + ' }', + ' }', + ' if (start >= 0) ranges.push(start, 0x10ffff, 1)', + ' return Uint32Array.from(ranges)', + '}', + '', + 'class LazyDecoder {', + ' private readonly initializer: Record V>', + ' private readonly cache: Map', + ' constructor(initializer: Record V>) {', + ' this.initializer = initializer', + ' this.cache = new Map()', + ' }', + ' has(key: string): boolean { return key in this.initializer }', + ' get(key: string): V | null {', + ' if (this.cache.has(key)) return this.cache.get(key)!', + ' const fn = this.initializer[key]', + ' const val = fn ? fn() : null', + ' this.cache.set(key, val)', + ' return val', + ' }', + '}', + '', + 'class UnicodeTables {', + ' private static _CASE_ORBIT: Map | null = null', + ' static get CASE_ORBIT(): Map {', + ' if (!this._CASE_ORBIT) {', + ` this._CASE_ORBIT = decodeOrbit('${orbitEnc}')`, + ' }', + ' return this._CASE_ORBIT', + ' }', + '', + ' // Additions from Unicode 15.0 → 16.0 per stable general-category name.', + ' // Merged unconditionally with platform sweep output; no-op on 16.0+ engines.', + ' private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({', + ...deltaCatLines, + ' })', + '', + ' // Additions from Unicode 15.0 → 16.0 per stable script name.', + ' private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({', + ...deltaScrLines, + ' })', + '', + ' // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw', + ' // SyntaxError on these names, so platform sweep is impossible.', + ' private static _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({', + ...newScriptLines, + ' })', + '', + ` static readonly STABLE_CATEGORY_NAMES: ReadonlySet = new Set(${JSON.stringify(stableCategoryNames)})`, + ` static readonly STABLE_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(stableScriptNames)})`, + ` static readonly NEW_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(newScriptNames)})`, + '', + ' private static _sweepCache = new Map()', + ' private static _foldCache = new Map()', + '', + ' // Returns the base range table for a property name, or null if unknown.', + ' // Stable names: platform sweep + bundled delta (15.0 → 16.0).', + ' // New-in-16.0 script names: bundled full table.', + ' static buildForProperty(name: string): UnicodeRangeTable | null {', + ' if (this.NEW_SCRIPT_NAMES.has(name)) {', + ' return this._NEW_SCRIPTS.get(name)', + ' }', + ' let kind: "category" | "script" | null = null', + ' let pattern: string | null = null', + ' if (this.STABLE_CATEGORY_NAMES.has(name)) { kind = "category"; pattern = `\\\\p{General_Category=${name}}` }', + ' else if (this.STABLE_SCRIPT_NAMES.has(name)) { kind = "script"; pattern = `\\\\p{Script=${name}}` }', + ' else return null', + '', + ' const cacheKey = `${kind}:${name}`', + ' const cached = this._sweepCache.get(cacheKey)', + ' if (cached) return cached', + '', + ' const base = sweepPlatform(pattern)', + ' const delta = kind === "category" ? this._DELTA_CATEGORIES.get(name) : this._DELTA_SCRIPTS.get(name)', + ' const merged = delta ? mergeRanges(base, delta) : base', + ' const table = new UnicodeRangeTable(merged)', + ' this._sweepCache.set(cacheKey, table)', + ' return table', + ' }', + '', + ' // Computes the fold-overlay for a property name: additional runes that', + ' // fold to some rune already in the base class. Returns null if no overlay', + ' // is needed (base class is fold-stable).', + ' static buildFoldOverlay(name: string): UnicodeRangeTable | null {', + ' const cached = this._foldCache.get(name)', + ' if (cached !== undefined) return cached', + ' const base = this.buildForProperty(name)', + ' if (!base) {', + ' this._foldCache.set(name, null)', + ' return null', + ' }', + ' const inBase = (r: number): boolean => {', + ' let lo = 0, hi = base.length', + ' while (lo < hi) {', + ' const m = (lo + hi) >> 1', + ' const rlo = base.getLo(m), rhi = base.getHi(m)', + ' if (r < rlo) hi = m', + ' else if (r > rhi) lo = m + 1', + ' else return ((r - rlo) % base.getStride(m)) === 0', + ' }', + ' return false', + ' }', + ' // Inline simpleFold to avoid circular import with Unicode.ts.', + ' const orbit = UnicodeTables.CASE_ORBIT', + ' const simpleFold = (r: number): number => {', + ' if (orbit.has(r)) return orbit.get(r)!', + ' const s = String.fromCodePoint(r)', + ' const lower = s.toLowerCase()', + ' if (lower.length === s.length) {', + ' const lowerCp = lower.codePointAt(0)!', + ' if (lowerCp !== r) return lowerCp', + ' }', + ' const upper = s.toUpperCase()', + ' if (upper.length === s.length) {', + ' const upperCp = upper.codePointAt(0)!', + ' if (upperCp !== r) return upperCp', + ' }', + ' return r', + ' }', + ' const extras = new Set()', + ' for (let i = 0; i < base.length; i++) {', + ' const lo = base.getLo(i), hi = base.getHi(i), stride = base.getStride(i)', + ' for (let cp = lo; cp <= hi; cp += stride) {', + ' let r = simpleFold(cp)', + ' while (r !== cp) {', + ' if (!inBase(r)) extras.add(r)', + ' r = simpleFold(r)', + ' }', + ' }', + ' }', + ' if (extras.size === 0) {', + ' this._foldCache.set(name, null)', + ' return null', + ' }', + ' const sorted = Array.from(extras).sort((a, b) => a - b)', + ' const merged: [number, number][] = []', + ' for (const cp of sorted) {', + ' const last = merged[merged.length - 1]', + ' if (last && last[1] + 1 === cp) last[1] = cp', + ' else merged.push([cp, cp])', + ' }', + ' const out = new Uint32Array(merged.length * 3)', + ' for (let i = 0; i < merged.length; i++) {', + ' out[i * 3] = merged[i][0]', + ' out[i * 3 + 1] = merged[i][1]', + ' out[i * 3 + 2] = 1', + ' }', + ' const table = new UnicodeRangeTable(out)', + ' this._foldCache.set(name, table)', + ' return table', + ' }', + '', + ' // --- Legacy API surface used by Parser ---', + '', + ' static CATEGORIES = {', + ' has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),', + ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)', + ' }', + '', + ' static SCRIPTS = {', + ' has: (name: string): boolean =>', + ' UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),', + ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)', + ' }', + '', + ' static FOLD_CATEGORIES = {', + ' has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),', + ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)', + ' }', + '', + ' static FOLD_SCRIPT = {', + ' has: (name: string): boolean =>', + ' UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),', + ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)', + ' }', + '', + ' static get Upper(): UnicodeRangeTable { return UnicodeTables.buildForProperty("Lu")! }', + '}', + '', + 'export { UnicodeTables }', + '' +] + +console.log(code.join('\n')) // eslint-disable-line no-console diff --git a/scripts/make_perl_groups.pl b/scripts/make_perl_groups.pl new file mode 100755 index 0000000..4b2e66f --- /dev/null +++ b/scripts/make_perl_groups.pl @@ -0,0 +1,126 @@ +#!/usr/bin/perl +# +# Copyright (c) 2020 The Go Authors. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file. +# + +# Modified version of make_perl_groups.pl from RE2J: +# https://github.com/google/re2j/blob/master/java/com/google/re2j/make_perl_groups.pl + +# Generate table entries giving character ranges +# for POSIX/Perl character classes. Rather than +# figure out what the definition is, it is easier to ask +# Perl about each letter from 0-128 and write down +# its answer. + +@posixclasses = ( + "[:alnum:]", + "[:alpha:]", + "[:ascii:]", + "[:blank:]", + "[:cntrl:]", + "[:digit:]", + "[:graph:]", + "[:lower:]", + "[:print:]", + "[:punct:]", + "[:space:]", + "[:upper:]", + "[:word:]", + "[:xdigit:]", +); + +@perlclasses = ( + "\\d", + "\\s", + "\\w", +); + +%overrides = ( + # Prior to Perl 5.18, \s did not match vertical tab. + # RE2 preserves that original behaviour. + "\\s:11" => 0, +); + +sub ComputeClass($) { + my @ranges; + my ($class) = @_; + my $regexp = "[$class]"; + my $start = -1; + for (my $i=0; $i<=129; $i++) { + if ($i == 129) { $i = 256; } + if ($i <= 128 && ($overrides{"$class:$i"} // chr($i) =~ $regexp)) { + if ($start < 0) { + $start = $i; + } + } else { + if ($start >= 0) { + push @ranges, [$start, $i-1]; + } + $start = -1; + } + } + return @ranges; +} + +sub PrintClass($$@) { + my ($cname, $groupmap, $name, @ranges) = @_; + print "const code$cname = [ /* $name */\n"; + for (my $i=0; $i<@ranges; $i++) { + my @a = @{$ranges[$i]}; + printf "\t0x%x, 0x%x,\n", $a[0], $a[1]; + } + print "]\n\n"; + my $n = @ranges; + $negname = $name; + if ($negname =~ /:/) { + $negname =~ s/:/:^/; + } else { + $negname =~ y/a-z/A-Z/; + } + $name =~ s/\\/\\\\/g; + $negname =~ s/\\/\\\\/g; + return "[\"$name\", \tnew CharGroup(+1, code$cname)],\n" . + "[\"$negname\", \tnew CharGroup(-1, code$cname)],\n"; +} + +my $gen = 0; + +sub PrintClasses($@) { + my ($cname, @classes) = @_; + my $groupmap = uc($cname) . "_GROUPS"; + my @entries; + foreach my $cl (@classes) { + my @ranges = ComputeClass($cl); + push @entries, PrintClass(++$gen, $groupmap, $cl, @ranges); + } + print "const $groupmap = new Map([\n"; + foreach my $e (@entries) { + print $e; + } + print "])\n"; + my $count = @entries; +} + +print < src/CharGroup.js + +class CharGroup { + constructor(sign, cls) { + this.sign = sign + this.cls = cls + } +} + +EOF + +PrintClasses("perl", @perlclasses); +PrintClasses("posix", @posixclasses); + +print < Date: Fri, 17 Apr 2026 16:07:11 -0400 Subject: [PATCH 02/13] fix imports --- package.json | 2 +- packages/cel-spec/src/testdata/conformance.ts | 31639 +--------------- packages/cel/src/re2/CharClass.ts | 6 +- packages/cel/src/re2/Compiler.ts | 14 +- packages/cel/src/re2/DFA.ts | 8 +- packages/cel/src/re2/Inst.ts | 4 +- packages/cel/src/re2/MachineInput.ts | 8 +- packages/cel/src/re2/Parser.ts | 24 +- packages/cel/src/re2/Prefilter.ts | 4 +- packages/cel/src/re2/Prog.ts | 4 +- packages/cel/src/re2/RE2.ts | 18 +- packages/cel/src/re2/Simplify.ts | 6 +- packages/cel/src/re2/Unicode.ts | 4 +- packages/cel/src/re2/UnicodeTables.ts | 2 +- packages/cel/src/re2/Utils.ts | 2 +- packages/cel/src/re2/__utils__/parser.ts | 6 +- packages/cel/tsconfig.json | 7 +- 17 files changed, 62 insertions(+), 31696 deletions(-) diff --git a/package.json b/package.json index 1eee930..1ee9136 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "private": true, - "scripts": {I am + "scripts": { "clean": "git clean -Xdf", "all": "turbo run --ui tui build format lint test attw license-header update-readme", "setversion": "node scripts/set-workspace-version.js", diff --git a/packages/cel-spec/src/testdata/conformance.ts b/packages/cel-spec/src/testdata/conformance.ts index 9c9703d..8ffbef0 100644 --- a/packages/cel-spec/src/testdata/conformance.ts +++ b/packages/cel-spec/src/testdata/conformance.ts @@ -1,31639 +1,2 @@ -// Copyright 2024-2026 Buf Technologies, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - // Generated from cel-go ../src/testdata/json -import type { SerializedIncrementalTestSuite } from "./tests.js"; -export const tests: SerializedIncrementalTestSuite = { - name: "conformance", - suites: [ - { - name: "basic", - suites: [ - { - name: "self_eval_zeroish", - tests: [ - { - original: { - name: "self_eval_int_zero", - expr: "0", - value: { int64Value: "0" }, - }, - ast: "0^#*expr.Constant_Int64Value#", - checkedAst: "0~int", - type: "int", - }, - { - original: { - name: "self_eval_uint_zero", - expr: "0u", - value: { uint64Value: "0" }, - }, - ast: "0u^#*expr.Constant_Uint64Value#", - checkedAst: "0u~uint", - type: "uint", - }, - { - original: { - name: "self_eval_uint_alias_zero", - expr: "0U", - value: { uint64Value: "0" }, - }, - ast: "0u^#*expr.Constant_Uint64Value#", - checkedAst: "0u~uint", - type: "uint", - }, - { - original: { - name: "self_eval_float_zero", - expr: "0.0", - value: { doubleValue: 0 }, - }, - ast: "0^#*expr.Constant_DoubleValue#", - checkedAst: "0~double", - type: "double", - }, - { - original: { - name: "self_eval_float_zerowithexp", - expr: "0e+0", - value: { doubleValue: 0 }, - }, - ast: "0^#*expr.Constant_DoubleValue#", - checkedAst: "0~double", - type: "double", - }, - { - original: { - name: "self_eval_string_empty", - expr: "''", - value: { stringValue: "" }, - }, - ast: '""^#*expr.Constant_StringValue#', - checkedAst: '""~string', - type: "string", - }, - { - original: { - name: "self_eval_string_empty_quotes", - expr: '""', - value: { stringValue: "" }, - }, - ast: '""^#*expr.Constant_StringValue#', - checkedAst: '""~string', - type: "string", - }, - { - original: { - name: "self_eval_string_raw_prefix", - expr: 'r""', - value: { stringValue: "" }, - }, - ast: '""^#*expr.Constant_StringValue#', - checkedAst: '""~string', - type: "string", - }, - { - original: { - name: "self_eval_bytes_empty", - expr: 'b""', - value: { bytesValue: "" }, - }, - ast: 'b""^#*expr.Constant_BytesValue#', - checkedAst: 'b""~bytes', - type: "bytes", - }, - { - original: { - name: "self_eval_bool_false", - expr: "false", - value: { boolValue: false }, - }, - ast: "false^#*expr.Constant_BoolValue#", - checkedAst: "false~bool", - type: "bool", - }, - { - original: { - name: "self_eval_null", - expr: "null", - value: { nullValue: null }, - }, - ast: "null^#*expr.Constant_NullValue#", - checkedAst: "null~null", - type: "null", - }, - { - original: { - name: "self_eval_empty_list", - expr: "[]", - value: { listValue: {} }, - }, - ast: "[]^#*expr.Expr_ListExpr#", - checkedAst: "[]~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "self_eval_empty_map", - expr: "{}", - value: { mapValue: {} }, - }, - ast: "{}^#*expr.Expr_StructExpr#", - checkedAst: "{}~map(dyn, dyn)", - type: "map(dyn, dyn)", - }, - { - original: { - name: "self_eval_string_raw_prefix_triple_double", - expr: 'r""""""', - value: { stringValue: "" }, - }, - ast: '""^#*expr.Constant_StringValue#', - checkedAst: '""~string', - type: "string", - }, - { - original: { - name: "self_eval_string_raw_prefix_triple_single", - expr: "r''''''", - value: { stringValue: "" }, - }, - ast: '""^#*expr.Constant_StringValue#', - checkedAst: '""~string', - type: "string", - }, - ], - }, - { - name: "self_eval_nonzeroish", - tests: [ - { - original: { - name: "self_eval_int_nonzero", - expr: "42", - value: { int64Value: "42" }, - }, - ast: "42^#*expr.Constant_Int64Value#", - checkedAst: "42~int", - type: "int", - }, - { - original: { - name: "self_eval_uint_nonzero", - expr: "123456789u", - value: { uint64Value: "123456789" }, - }, - ast: "123456789u^#*expr.Constant_Uint64Value#", - checkedAst: "123456789u~uint", - type: "uint", - }, - { - original: { - name: "self_eval_uint_alias_nonzero", - expr: "123456789U", - value: { uint64Value: "123456789" }, - }, - ast: "123456789u^#*expr.Constant_Uint64Value#", - checkedAst: "123456789u~uint", - type: "uint", - }, - { - original: { - name: "self_eval_int_negative_min", - expr: "-9223372036854775808", - value: { int64Value: "-9223372036854775808" }, - }, - ast: "-9223372036854775808^#*expr.Constant_Int64Value#", - checkedAst: "-9223372036854775808~int", - type: "int", - }, - { - original: { - name: "self_eval_float_negative_exp", - expr: "-2.3e+1", - value: { doubleValue: -23 }, - }, - ast: "-23^#*expr.Constant_DoubleValue#", - checkedAst: "-23~double", - type: "double", - }, - { - original: { - name: "self_eval_string_excl", - expr: '"!"', - value: { stringValue: "!" }, - }, - ast: '"!"^#*expr.Constant_StringValue#', - checkedAst: '"!"~string', - type: "string", - }, - { - original: { - name: "self_eval_string_escape", - expr: "'\\''", - value: { stringValue: "'" }, - }, - ast: '"\'"^#*expr.Constant_StringValue#', - checkedAst: '"\'"~string', - type: "string", - }, - { - original: { - name: "self_eval_bytes_escape", - expr: "b'ÿ'", - value: { bytesValue: "w78=" }, - }, - ast: 'b"ÿ"^#*expr.Constant_BytesValue#', - checkedAst: 'b"ÿ"~bytes', - type: "bytes", - }, - { - original: { - name: "self_eval_bytes_invalid_utf8", - expr: "b'\\000\\xff'", - value: { bytesValue: "AP8=" }, - }, - ast: 'b"\\x00\\xff"^#*expr.Constant_BytesValue#', - checkedAst: 'b"\\x00\\xff"~bytes', - type: "bytes", - }, - { - original: { - name: "self_eval_list_singleitem", - expr: "[-1]", - value: { listValue: { values: [{ int64Value: "-1" }] } }, - }, - ast: "[\n -1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#", - checkedAst: "[\n -1~int\n]~list(int)", - type: "list(int)", - }, - { - original: { - name: "self_eval_map_singleitem", - expr: '{"k":"v"}', - value: { - mapValue: { - entries: [ - { - key: { stringValue: "k" }, - value: { stringValue: "v" }, - }, - ], - }, - }, - }, - ast: '{\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: '{\n "k"~string:"v"~string\n}~map(string, string)', - type: "map(string, string)", - }, - { - original: { - name: "self_eval_bool_true", - expr: "true", - value: { boolValue: true }, - }, - ast: "true^#*expr.Constant_BoolValue#", - checkedAst: "true~bool", - type: "bool", - }, - { - original: { - name: "self_eval_int_hex", - expr: "0x55555555", - value: { int64Value: "1431655765" }, - }, - ast: "1431655765^#*expr.Constant_Int64Value#", - checkedAst: "1431655765~int", - type: "int", - }, - { - original: { - name: "self_eval_int_hex_negative", - expr: "-0x55555555", - value: { int64Value: "-1431655765" }, - }, - ast: "-1431655765^#*expr.Constant_Int64Value#", - checkedAst: "-1431655765~int", - type: "int", - }, - { - original: { - name: "self_eval_uint_hex", - expr: "0x55555555u", - value: { uint64Value: "1431655765" }, - }, - ast: "1431655765u^#*expr.Constant_Uint64Value#", - checkedAst: "1431655765u~uint", - type: "uint", - }, - { - original: { - name: "self_eval_uint_alias_hex", - expr: "0x55555555U", - value: { uint64Value: "1431655765" }, - }, - ast: "1431655765u^#*expr.Constant_Uint64Value#", - checkedAst: "1431655765u~uint", - type: "uint", - }, - { - original: { - name: "self_eval_unicode_escape_four", - expr: '"\\u270c"', - value: { stringValue: "✌" }, - }, - ast: '"✌"^#*expr.Constant_StringValue#', - checkedAst: '"✌"~string', - type: "string", - }, - { - original: { - name: "self_eval_unicode_escape_eight", - expr: '"\\U0001f431"', - value: { stringValue: "🐱" }, - }, - ast: '"🐱"^#*expr.Constant_StringValue#', - checkedAst: '"🐱"~string', - type: "string", - }, - { - original: { - name: "self_eval_ascii_escape_seq", - expr: '"\\a\\b\\f\\n\\r\\t\\v\\"\\\'\\\\"', - value: { stringValue: "\u0007\b\f\n\r\t\u000b\"'\\" }, - }, - ast: '"\\a\\b\\f\\n\\r\\t\\v\\"\'\\\\"^#*expr.Constant_StringValue#', - checkedAst: '"\\a\\b\\f\\n\\r\\t\\v\\"\'\\\\"~string', - type: "string", - }, - ], - }, - { - name: "variables", - tests: [ - { - original: { - name: "self_eval_bound_lookup", - expr: "x", - typeEnv: [ - { name: "x", ident: { type: { primitive: "INT64" } } }, - ], - bindings: { x: { value: { int64Value: "123" } } }, - value: { int64Value: "123" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~int^x", - type: "int", - }, - { - original: { - name: "self_eval_unbound_lookup", - description: - "An unbound variable should be marked as an error during execution. See google/cel-go#154", - expr: "x", - disableCheck: true, - evalError: { - errors: [ - { - message: "undeclared reference to 'x' (in container '')", - }, - ], - }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x\n | ^", - }, - { - original: { - name: "unbound_is_runtime_error", - description: - "Make sure we can short-circuit around an unbound variable.", - expr: "x || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n x^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x || true\n | ^", - }, - ], - }, - { - name: "functions", - tests: [ - { - original: { - name: "binop", - expr: "1 + 1", - value: { int64Value: "2" }, - }, - ast: "_+_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 1~int,\n 1~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "unbound", - expr: "f_unknown(17)", - disableCheck: true, - evalError: { errors: [{ message: "unbound function" }] }, - }, - ast: "f_unknown(\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17)\n | .........^", - }, - { - original: { - name: "unbound_is_runtime_error", - expr: "f_unknown(17) || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n f_unknown(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17) || true\n | .........^", - }, - ], - }, - { - name: "reserved_const", - tests: [ - { - original: { - name: "false", - expr: "false", - typeEnv: [ - { name: "false", ident: { type: { primitive: "BOOL" } } }, - ], - bindings: { false: { value: { boolValue: true } } }, - value: { boolValue: false }, - }, - ast: "false^#*expr.Constant_BoolValue#", - checkedAst: "false~bool", - type: "bool", - }, - { - original: { - name: "true", - expr: "true", - typeEnv: [ - { name: "true", ident: { type: { primitive: "BOOL" } } }, - ], - bindings: { true: { value: { boolValue: false } } }, - value: { boolValue: true }, - }, - ast: "true^#*expr.Constant_BoolValue#", - checkedAst: "true~bool", - type: "bool", - }, - { - original: { - name: "null", - expr: "null", - typeEnv: [ - { name: "null", ident: { type: { primitive: "BOOL" } } }, - ], - bindings: { null: { value: { boolValue: true } } }, - value: { nullValue: null }, - }, - ast: "null^#*expr.Constant_NullValue#", - checkedAst: "null~null", - type: "null", - }, - ], - }, - ], - }, - { - name: "bindings_ext", - suites: [ - { - name: "bind", - tests: [ - { - original: { - name: "boolean_literal", - expr: "cel.bind(t, true, t)", - value: { boolValue: true }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.bind(\n t^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n t^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t~bool^t,\n // Result\n t~bool^t)~bool", - type: "bool", - }, - { - original: { - name: "string_concat", - expr: 'cel.bind(msg, "hello", msg + msg + msg)', - value: { stringValue: "hellohellohello" }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.bind(\n msg^#*expr.Expr_IdentExpr#,\n "hello"^#*expr.Constant_StringValue#,\n _+_(\n _+_(\n msg^#*expr.Expr_IdentExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n msg,\n // Init\n "hello"~string,\n // LoopCondition\n false~bool,\n // LoopStep\n msg~string^msg,\n // Result\n _+_(\n _+_(\n msg~string^msg,\n msg~string^msg\n )~string^add_string,\n msg~string^msg\n )~string^add_string)~string', - type: "string", - }, - { - original: { - name: "bind_nested", - expr: "cel.bind(t1, true, cel.bind(t2, true, t1 \u0026\u0026 t2))", - value: { boolValue: true }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.bind(\n t1^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.bind(\n t2^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n _\u0026\u0026_(\n t1^#*expr.Expr_IdentExpr#,\n t2^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t1,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t1~bool^t1,\n // Result\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t2,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t2~bool^t2,\n // Result\n _\u0026\u0026_(\n t1~bool^t1,\n t2~bool^t2\n )~bool^logical_and)~bool)~bool", - type: "bool", - }, - { - original: { - name: "macro_exists", - expr: "cel.bind(valid_elems, [1, 2, 3], [3, 4, 5].exists(e, e in valid_elems))", - value: { boolValue: true }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool)~bool", - type: "bool", - }, - { - original: { - name: "macro_not_exists", - expr: "cel.bind(valid_elems, [1, 2, 3], ![4, 5].exists(e, e in valid_elems))", - value: { boolValue: true }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_not)~bool", - type: "bool", - }, - ], - }, - ], - }, - { - name: "block_ext", - suites: [ - { - name: "basic", - tests: [ - { - original: { - name: "int_add", - expr: "cel.block([1, cel.index(0) + 1, cel.index(1) + 1, cel.index(2) + 1], cel.index(3))", - value: { int64Value: "4" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n 1^#*expr.Constant_Int64Value#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n 1~int,\n _+_(\n @index0~dyn^@index0,\n 1~int\n )~int^add_int64,\n _+_(\n @index1~dyn^@index1,\n 1~int\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(int),\n @index3~dyn^@index3\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "size_1", - expr: "cel.block([[1, 2], size(cel.index(0)), cel.index(1) + cel.index(1), cel.index(2) + 1], cel.index(3))", - value: { int64Value: "5" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "size_2", - expr: "cel.block([[1, 2], size(cel.index(0)), 2 + cel.index(1), cel.index(2) + cel.index(1), cel.index(3) + 1], cel.index(4))", - value: { int64Value: "7" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 2~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index3~dyn^@index3,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "size_3", - expr: "cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), cel.index(1) + cel.index(1), cel.index(4) + cel.index(3), cel.index(5) + cel.index(3)], cel.index(6))", - value: { int64Value: "6" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index5~dyn^@index5,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "size_4", - expr: "cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), [1, 2, 3], size(cel.index(4)), 5 + cel.index(1), cel.index(6) + cel.index(1), cel.index(7) + cel.index(3), cel.index(8) + cel.index(3), cel.index(9) + cel.index(5), cel.index(10) + cel.index(5)], cel.index(11))", - value: { int64Value: "17" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n size(\n @index4~dyn^@index4\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 5~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index6~dyn^@index6,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index7~dyn^@index7,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index8~dyn^@index8,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index9~dyn^@index9,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index10~dyn^@index10,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "timestamp", - expr: "cel.block([timestamp(1000000000), int(cel.index(0)), timestamp(cel.index(1)), cel.index(2).getFullYear(), timestamp(50), int(cel.index(4)), timestamp(cel.index(5)), timestamp(200), int(cel.index(7)), timestamp(cel.index(8)), cel.index(9).getFullYear(), timestamp(75), int(cel.index(11)), timestamp(cel.index(12)), cel.index(13).getFullYear(), cel.index(3) + cel.index(14), cel.index(6).getFullYear(), cel.index(15) + cel.index(16), cel.index(17) + cel.index(3), cel.index(6).getSeconds(), cel.index(18) + cel.index(19), cel.index(20) + cel.index(10), cel.index(21) + cel.index(10), cel.index(13).getMinutes(), cel.index(22) + cel.index(23), cel.index(24) + cel.index(3)], cel.index(25))", - value: { int64Value: "13934" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 200^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 14^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 16^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 18^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 19^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 21^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp,\n int(\n @index0~dyn^@index0\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index1~dyn^@index1\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index2~dyn^@index2.getFullYear()~int^timestamp_to_year,\n timestamp(\n 50~int\n )~timestamp^int64_to_timestamp,\n int(\n @index4~dyn^@index4\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index5~dyn^@index5\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n timestamp(\n 200~int\n )~timestamp^int64_to_timestamp,\n int(\n @index7~dyn^@index7\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index8~dyn^@index8\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index9~dyn^@index9.getFullYear()~int^timestamp_to_year,\n timestamp(\n 75~int\n )~timestamp^int64_to_timestamp,\n int(\n @index11~dyn^@index11\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index12~dyn^@index12\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index13~dyn^@index13.getFullYear()~int^timestamp_to_year,\n _+_(\n @index3~dyn^@index3,\n @index14~dyn^@index14\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getFullYear()~int^timestamp_to_year,\n _+_(\n @index15~dyn^@index15,\n @index16~dyn^@index16\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index17~dyn^@index17,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getSeconds()~int^duration_to_seconds|timestamp_to_seconds,\n _+_(\n @index18~dyn^@index18,\n @index19~dyn^@index19\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index20~dyn^@index20,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index21~dyn^@index21,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index13~dyn^@index13.getMinutes()~int^duration_to_minutes|timestamp_to_minutes,\n _+_(\n @index22~dyn^@index22,\n @index23~dyn^@index23\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index24~dyn^@index24,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index25~dyn^@index25\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "map_index", - expr: 'cel.block([{"a": 2}, cel.index(0)["a"], cel.index(1) * cel.index(1), cel.index(1) + cel.index(2)], cel.index(3))', - value: { int64Value: "6" }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "a"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "a"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n {\n "a"~string:2~int\n }~map(string, int),\n _[_](\n @index0~dyn^@index0,\n "a"~string\n )~dyn^index_map|optional_map_index_value,\n _*_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^multiply_double|multiply_int64|multiply_uint64,\n _+_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list', - type: "dyn", - }, - { - original: { - name: "nested_map_construction", - expr: 'cel.block([{"b": 1}, {"e": cel.index(0)}], {"a": cel.index(0), "c": cel.index(0), "d": cel.index(1), "e": cel.index(1)})', - value: { - mapValue: { - entries: [ - { - key: { stringValue: "a" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "b" }, - value: { int64Value: "1" }, - }, - ], - }, - }, - }, - { - key: { stringValue: "c" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "b" }, - value: { int64Value: "1" }, - }, - ], - }, - }, - }, - { - key: { stringValue: "d" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "e" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "b" }, - value: { int64Value: "1" }, - }, - ], - }, - }, - }, - ], - }, - }, - }, - { - key: { stringValue: "e" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "e" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "b" }, - value: { int64Value: "1" }, - }, - ], - }, - }, - }, - ], - }, - }, - }, - ], - }, - }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "b"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "e"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n {\n "a"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "c"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "d"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "e"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n {\n "b"~string:1~int\n }~map(string, int),\n {\n "e"~string:@index0~dyn^@index0\n }~map(string, dyn)\n ]~list(map(string, dyn)),\n {\n "a"~string:@index0~dyn^@index0,\n "c"~string:@index0~dyn^@index0,\n "d"~string:@index1~dyn^@index1,\n "e"~string:@index1~dyn^@index1\n }~map(string, dyn)\n)~map(string, dyn)^cel_block_list', - type: "map(string, dyn)", - }, - { - original: { - name: "nested_list_construction", - expr: "cel.block([[1, 2, 3, 4], [1, 2], [cel.index(1), cel.index(0)]], [1, cel.index(0), 2, cel.index(0), 5, cel.index(0), 7, cel.index(2), cel.index(1)])", - value: { - listValue: { - values: [ - { int64Value: "1" }, - { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - { int64Value: "2" }, - { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - { int64Value: "5" }, - { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - { int64Value: "7" }, - { - listValue: { - values: [ - { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - ], - }, - }, - { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - ], - }, - }, - { - listValue: { - values: [{ int64Value: "1" }, { int64Value: "2" }], - }, - }, - ], - }, - }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n [\n 1~int,\n 2~int\n ]~list(int),\n [\n @index1~dyn^@index1,\n @index0~dyn^@index0\n ]~list(dyn)\n ]~list(list(dyn)),\n [\n 1~int,\n @index0~dyn^@index0,\n 2~int,\n @index0~dyn^@index0,\n 5~int,\n @index0~dyn^@index0,\n 7~int,\n @index2~dyn^@index2,\n @index1~dyn^@index1\n ]~list(dyn)\n)~list(dyn)^cel_block_list", - type: "list(dyn)", - }, - { - original: { - name: "select", - expr: "cel.block([msg.single_int64, cel.index(0) + cel.index(0)], cel.index(1))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "6" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index0~dyn^@index0,\n @index0~dyn^@index0\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index1~dyn^@index1\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "select_nested_1", - expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, cel.index(1).single_int32, cel.index(2) + cel.index(3), cel.index(4) + cel.index(2), msg.single_int64, cel.index(5) + cel.index(6), cel.index(1).oneof_type, cel.index(8).payload, cel.index(9).single_int64, cel.index(7) + cel.index(10)], cel.index(11))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "31" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int32~dyn,\n _+_(\n @index2~dyn^@index2,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index1~dyn^@index1.oneof_type~dyn,\n @index8~dyn^@index8.payload~dyn,\n @index9~dyn^@index9.single_int64~dyn,\n _+_(\n @index7~dyn^@index7,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "select_nested_2", - expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).oneof_type, cel.index(2).payload, cel.index(3).oneof_type, cel.index(4).payload, cel.index(5).oneof_type, cel.index(6).payload, cel.index(7).single_bool, true || cel.index(8), cel.index(4).child, cel.index(10).child, cel.index(11).payload, cel.index(12).single_bool], cel.index(9) || cel.index(13))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { boolValue: true }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#,\n _||_(\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _||_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.oneof_type~dyn,\n @index2~dyn^@index2.payload~dyn,\n @index3~dyn^@index3.oneof_type~dyn,\n @index4~dyn^@index4.payload~dyn,\n @index5~dyn^@index5.oneof_type~dyn,\n @index6~dyn^@index6.payload~dyn,\n @index7~dyn^@index7.single_bool~dyn,\n _||_(\n true~bool,\n @index8~dyn^@index8\n )~bool^logical_or,\n @index4~dyn^@index4.child~dyn,\n @index10~dyn^@index10.child~dyn,\n @index11~dyn^@index11.payload~dyn,\n @index12~dyn^@index12.single_bool~dyn\n ]~list(dyn),\n _||_(\n @index9~dyn^@index9,\n @index13~dyn^@index13\n )~bool^logical_or\n)~bool^cel_block_list", - type: "bool", - }, - { - original: { - name: "select_nested_message_map_index_1", - expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[1], cel.index(3) + cel.index(3), cel.index(4) + cel.index(3)], cel.index(5))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "15" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "select_nested_message_map_index_2", - expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[0], cel.index(2)[1], cel.index(3) + cel.index(4), cel.index(2)[2], cel.index(5) + cel.index(6)], cel.index(7))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "8" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 0~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _[_](\n @index2~dyn^@index2,\n 2~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index7~dyn^@index7\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "ternary", - expr: "cel.block([msg.single_int64, cel.index(0) \u003e 0, cel.index(1) ? cel.index(0) : 0], cel.index(2))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "3" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _?_:_(\n @index1~dyn^@index1,\n @index0~dyn^@index0,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index2~dyn^@index2\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "nested_ternary", - expr: "cel.block([msg.single_int64, msg.single_int32, cel.index(0) \u003e 0, cel.index(1) \u003e 0, cel.index(0) + cel.index(1), cel.index(3) ? cel.index(4) : 0, cel.index(2) ? cel.index(5) : 0], cel.index(6))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "8" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int32~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _\u003e_(\n @index1~dyn^@index1,\n 0~int\n )~bool^greater_int64,\n _+_(\n @index0~dyn^@index0,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _?_:_(\n @index3~dyn^@index3,\n @index4~dyn^@index4,\n 0~int\n )~dyn^conditional,\n _?_:_(\n @index2~dyn^@index2,\n @index5~dyn^@index5,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "multiple_macros_1", - expr: "cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))", - value: { int64Value: "4" }, - }, - error: - "ERROR: multiple_macros_1:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_1:1:110: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .............................................................................................................^", - }, - { - original: { - name: "multiple_macros_2", - expr: "cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))", - value: { - listValue: { - values: [ - { boolValue: true }, - { boolValue: true }, - { boolValue: true }, - { boolValue: true }, - ], - }, - }, - }, - error: - "ERROR: multiple_macros_2:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_2:1:106: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .........................................................................................................^", - }, - { - original: { - name: "multiple_macros_3", - expr: "cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))", - value: { boolValue: false }, - }, - error: - "ERROR: multiple_macros_3:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | .................................^\nERROR: multiple_macros_3:1:121: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ........................................................................................................................^\nERROR: multiple_macros_3:1:177: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ................................................................................................................................................................................^", - }, - { - original: { - name: "nested_macros_1", - expr: "cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))", - value: { - listValue: { - values: [ - { - listValue: { - values: [ - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - { - listValue: { - values: [ - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - { - listValue: { - values: [ - { int64Value: "2" }, - { int64Value: "3" }, - { int64Value: "4" }, - ], - }, - }, - ], - }, - }, - }, - error: - "ERROR: nested_macros_1:1:52: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | ...................................................^\nERROR: nested_macros_1:1:88: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | .......................................................................................^", - }, - { - original: { - name: "nested_macros_2", - expr: "[1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))", - value: { - listValue: { - values: [ - { listValue: { values: [{ int64Value: "1" }] } }, - { listValue: { values: [{ int64Value: "2" }] } }, - ], - }, - }, - }, - error: - "ERROR: nested_macros_2:1:23: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ......................^\nERROR: nested_macros_2:1:59: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ..........................................................^", - }, - { - original: { - name: "adjacent_macros", - expr: "cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))", - value: { boolValue: true }, - }, - error: - "ERROR: adjacent_macros:1:51: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ..................................................^\nERROR: adjacent_macros:1:87: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ......................................................................................^", - }, - { - original: { - name: "macro_shadowed_variable_1", - expr: "cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))", - typeEnv: [ - { name: "x", ident: { type: { primitive: "INT64" } } }, - ], - bindings: { x: { value: { int64Value: "5" } } }, - value: { boolValue: true }, - }, - error: - "ERROR: macro_shadowed_variable_1:1:90: argument must be a simple name\n | cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))\n | .........................................................................................^", - }, - { - original: { - name: "macro_shadowed_variable_2", - expr: "['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])", - typeEnv: [ - { name: "x", ident: { type: { primitive: "INT64" } } }, - ], - bindings: { x: { value: { int64Value: "5" } } }, - value: { - listValue: { - values: [ - { - listValue: { - values: [ - { - listValue: { - values: [ - { stringValue: "foofoo" }, - { stringValue: "foofoo" }, - { stringValue: "foofoo" }, - { stringValue: "foofoo" }, - ], - }, - }, - { - listValue: { - values: [ - { stringValue: "foofoo" }, - { stringValue: "foofoo" }, - { stringValue: "foofoo" }, - { stringValue: "foofoo" }, - ], - }, - }, - ], - }, - }, - { - listValue: { - values: [ - { - listValue: { - values: [ - { stringValue: "barbar" }, - { stringValue: "barbar" }, - { stringValue: "barbar" }, - { stringValue: "barbar" }, - ], - }, - }, - { - listValue: { - values: [ - { stringValue: "barbar" }, - { stringValue: "barbar" }, - { stringValue: "barbar" }, - { stringValue: "barbar" }, - ], - }, - }, - ], - }, - }, - ], - }, - }, - }, - error: - "ERROR: macro_shadowed_variable_2:1:31: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | ..............................^\nERROR: macro_shadowed_variable_2:1:134: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | .....................................................................................................................................^", - }, - { - original: { - name: "inclusion_list", - expr: "cel.block([[1, 2, 3], 1 in cel.index(0), 2 in cel.index(0), cel.index(1) \u0026\u0026 cel.index(2), [3, cel.index(0)], 3 in cel.index(4), cel.index(5) \u0026\u0026 cel.index(1)], cel.index(3) \u0026\u0026 cel.index(6))", - value: { boolValue: true }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n @in(\n 1~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n @in(\n 2~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and,\n [\n 3~int,\n @index0~dyn^@index0\n ]~list(dyn),\n @in(\n 3~int,\n @index4~dyn^@index4\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index1~dyn^@index1\n )~bool^logical_and\n ]~list(dyn),\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index6~dyn^@index6\n )~bool^logical_and\n)~bool^cel_block_list", - type: "bool", - }, - { - original: { - name: "inclusion_map", - expr: 'cel.block([{true: false}, {"a": 1, 2: cel.index(0), 3: cel.index(0)}], 2 in cel.index(1))', - value: { boolValue: true }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n true^#*expr.Constant_BoolValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n {\n true~bool:false~bool\n }~map(bool, bool),\n {\n "a"~string:1~int,\n 2~int:@index0~dyn^@index0,\n 3~int:@index0~dyn^@index0\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn)),\n @in(\n 2~int,\n @index1~dyn^@index1\n )~bool^in_list|in_map\n)~bool^cel_block_list', - type: "bool", - }, - { - original: { - name: "presence_test", - expr: 'cel.block([{"a": true}, has(cel.index(0).a), cel.index(0)["a"]], cel.index(1) \u0026\u0026 cel.index(2))', - value: { boolValue: true }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "a"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "a"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n {\n "a"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool,\n _[_](\n @index0~dyn^@index0,\n "a"~string\n )~dyn^index_map|optional_map_index_value\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and\n)~bool^cel_block_list', - type: "bool", - }, - { - original: { - name: "presence_test_2", - expr: 'cel.block([{"a": true}, has(cel.index(0).a)], cel.index(1) \u0026\u0026 cel.index(1))', - value: { boolValue: true }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "a"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n {\n "a"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~bool^logical_and\n)~bool^cel_block_list', - type: "bool", - }, - { - original: { - name: "presence_test_with_ternary", - expr: "cel.block([msg.oneof_type, has(cel.index(0).payload), cel.index(0).payload, cel.index(2).single_int64, cel.index(1) ? cel.index(3) : 0], cel.index(4))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "10" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~test-only~~bool,\n @index0~dyn^@index0.payload~dyn,\n @index2~dyn^@index2.single_int64~dyn,\n _?_:_(\n @index1~dyn^@index1,\n @index3~dyn^@index3,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "presence_test_with_ternary_2", - expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(0).payload), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "10" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index0~dyn^@index0.payload~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "presence_test_with_ternary_3", - expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(1).single_int64), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { int64Value: "10" }, - }, - ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list", - type: "dyn", - }, - { - original: { - name: "presence_test_with_ternary_nested", - expr: 'cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_string_string, has(msg.oneof_type), has(cel.index(0).payload), cel.index(3) \u0026\u0026 cel.index(4), has(cel.index(1).single_int64), cel.index(5) \u0026\u0026 cel.index(6), has(cel.index(1).map_string_string), has(cel.index(2).key), cel.index(8) \u0026\u0026 cel.index(9), cel.index(2).key, cel.index(11) == "A", cel.index(10) ? cel.index(12) : false], cel.index(7) ? cel.index(13) : false)', - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 5, - singleInt64: "3", - oneofType: { - payload: { - singleInt32: 8, - singleInt64: "10", - mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, - mapStringString: { key: "A" }, - }, - }, - }, - }, - }, - }, - value: { boolValue: true }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.oneof_type~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key^#*expr.Expr_SelectExpr#,\n _==_(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "A"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_string_string~dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~test-only~~bool,\n @index0~dyn^@index0.payload~test-only~~bool,\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~bool^logical_and,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~bool^logical_and,\n @index1~dyn^@index1.map_string_string~test-only~~bool,\n @index2~dyn^@index2.key~test-only~~bool,\n _\u0026\u0026_(\n @index8~dyn^@index8,\n @index9~dyn^@index9\n )~bool^logical_and,\n @index2~dyn^@index2.key~dyn,\n _==_(\n @index11~dyn^@index11,\n "A"~string\n )~bool^equals,\n _?_:_(\n @index10~dyn^@index10,\n @index12~dyn^@index12,\n false~bool\n )~dyn^conditional\n ]~list(dyn),\n _?_:_(\n @index7~dyn^@index7,\n @index13~dyn^@index13,\n false~bool\n )~dyn^conditional\n)~dyn^cel_block_list', - type: "dyn", - }, - { - original: { - name: "optional_list", - expr: "cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))", - typeEnv: [ - { name: "opt_x", ident: { type: { primitive: "INT64" } } }, - ], - bindings: { opt_x: { value: { int64Value: "5" } } }, - value: { boolValue: true }, - }, - error: - "ERROR: optional_list:1:30: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | .............................^\nERROR: optional_list:1:45: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................^\nERROR: optional_list:1:77: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................................................^", - }, - { - original: { - name: "optional_map", - expr: 'cel.block([optional.of("hello"), {?"hello": cel.index(0)}, cel.index(1)["hello"], cel.index(2) + cel.index(2)], cel.index(3) == "hellohello")', - value: { boolValue: true }, - }, - error: - 'ERROR: optional_map:1:35: unsupported syntax \'?\'\n | cel.block([optional.of("hello"), {?"hello": cel.index(0)}, cel.index(1)["hello"], cel.index(2) + cel.index(2)], cel.index(3) == "hellohello")\n | ..................................^', - }, - { - original: { - name: "optional_map_chained", - expr: 'cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))', - value: { stringValue: "test" }, - }, - error: - 'ERROR: optional_map_chained:1:51: unsupported syntax \'?\'\n | cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | ..................................................^\nERROR: optional_map_chained:1:86: unsupported syntax \'[?\'\n | cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .....................................................................................^\nERROR: optional_map_chained:1:110: unsupported syntax \'[?\'\n | cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .............................................................................................................^', - }, - { - original: { - name: "optional_message", - expr: "cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))", - container: "cel.expr.conformance.proto3", - value: { int64Value: "5" }, - }, - error: - "ERROR: optional_message:1:69: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | ....................................................................^\nERROR: optional_message:1:98: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | .................................................................................................^", - }, - { - original: { - name: "call", - expr: 'cel.block(["h" + "e", cel.index(0) + "l", cel.index(1) + "l", cel.index(2) + "o", cel.index(3) + " world"], cel.index(4).matches(cel.index(3)))', - value: { boolValue: true }, - }, - ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n _+_(\n "h"^#*expr.Constant_StringValue#,\n "e"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "l"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "l"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "o"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n " world"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.matches(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'cel.@block(\n [\n _+_(\n "h"~string,\n "e"~string\n )~string^add_string,\n _+_(\n @index0~dyn^@index0,\n "l"~string\n )~string^add_string,\n _+_(\n @index1~dyn^@index1,\n "l"~string\n )~string^add_string,\n _+_(\n @index2~dyn^@index2,\n "o"~string\n )~string^add_string,\n _+_(\n @index3~dyn^@index3,\n " world"~string\n )~string^add_string\n ]~list(string),\n @index4~dyn^@index4.matches(\n @index3~dyn^@index3\n )~bool^matches_string\n)~bool^cel_block_list', - type: "bool", - }, - ], - }, - ], - }, - { - name: "comparisons", - suites: [ - { - name: "eq_literal", - tests: [ - { - original: { - name: "eq_int", - expr: "1 == 1", - value: { boolValue: true }, - }, - ast: "_==_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n 1~int,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_int", - expr: "-1 == 1", - value: { boolValue: false }, - }, - ast: "_==_(\n -1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n -1~int,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int_uint", - expr: "dyn(1) == 1u", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_int_uint", - expr: "dyn(2) == 1u", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int_double", - expr: "dyn(1) == 1.0", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_int_double", - expr: "dyn(2) == 1.0", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint", - expr: "2u == 2u", - value: { boolValue: true }, - }, - ast: "_==_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n 2u~uint,\n 2u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_uint", - expr: "1u == 2u", - value: { boolValue: false }, - }, - ast: "_==_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n 1u~uint,\n 2u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint_int", - expr: "dyn(1u) == 1", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_uint_int", - expr: "dyn(2u) == 1", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint_double", - expr: "dyn(1u) == 1.0", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_uint_double", - expr: "dyn(2u) == 1.0", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double", - expr: "1.0 == 1.0e+0", - value: { boolValue: true }, - }, - ast: "_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n 1~double,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_double", - expr: "-1.0 == 1.0", - value: { boolValue: false }, - }, - ast: "_==_(\n -1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n -1~double,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_double_nan", - expr: "0.0/0.0 == 0.0/0.0", - value: { boolValue: false }, - }, - ast: "_==_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_int_double_nan", - expr: "dyn(1) == 0.0/0.0", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_uint_double_nan", - expr: "dyn(1u) == 0.0/0.0", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double_int", - expr: "dyn(1.0) == 1", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_double_int", - expr: "dyn(2.0) == 1", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double_uint", - expr: "dyn(1.0) == 1u", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_double_uint", - expr: "dyn(2.0) == 1u", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_string", - expr: "'' == \"\"", - value: { boolValue: true }, - }, - ast: '_==_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: '_==_(\n ""~string,\n ""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_string", - expr: "'a' == 'b'", - value: { boolValue: false }, - }, - ast: '_==_(\n "a"^#*expr.Constant_StringValue#,\n "b"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: '_==_(\n "a"~string,\n "b"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_raw_string", - expr: "'abc' == r'abc'", - value: { boolValue: true }, - }, - ast: '_==_(\n "abc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "abc"~string,\n "abc"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_string_case", - expr: "'abc' == 'ABC'", - value: { boolValue: false }, - }, - ast: '_==_(\n "abc"^#*expr.Constant_StringValue#,\n "ABC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "abc"~string,\n "ABC"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_string_unicode", - expr: "'ίσος' == 'ίσος'", - value: { boolValue: true }, - }, - ast: '_==_(\n "ίσος"^#*expr.Constant_StringValue#,\n "ίσος"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ίσος"~string,\n "ίσος"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_string_unicode_ascii", - expr: "'a' == 'à'", - value: { boolValue: false }, - }, - ast: '_==_(\n "a"^#*expr.Constant_StringValue#,\n "à"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: '_==_(\n "a"~string,\n "à"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "no_string_normalization", - description: "Should not normalize Unicode.", - expr: "'Am\\u00E9lie' == 'Ame\\u0301lie'", - value: { boolValue: false }, - }, - ast: '_==_(\n "Amélie"^#*expr.Constant_StringValue#,\n "Amélie"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "Amélie"~string,\n "Amélie"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_null", - expr: "null == null", - value: { boolValue: true }, - }, - ast: "_==_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n null~null,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bool", - expr: "true == true", - value: { boolValue: true }, - }, - ast: "_==_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n true~bool,\n true~bool\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_bool", - expr: "false == true", - value: { boolValue: false }, - }, - ast: "_==_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n false~bool,\n true~bool\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bytes", - description: "Test bytes literal equality with encoding", - expr: "b'ÿ' == b'\\303\\277'", - value: { boolValue: true }, - }, - ast: '_==_(\n b"ÿ"^#*expr.Constant_BytesValue#,\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: '_==_(\n b"ÿ"~bytes,\n b"ÿ"~bytes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_bytes", - expr: "b'abc' == b'abcd'", - value: { boolValue: false }, - }, - ast: '_==_(\n b"abc"^#*expr.Constant_BytesValue#,\n b"abcd"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n b"abc"~bytes,\n b"abcd"~bytes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_list_empty", - expr: "[] == []", - value: { boolValue: true }, - }, - ast: "_==_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n []~list(dyn),\n []~list(dyn)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_list_null", - expr: "[null] == [null]", - value: { boolValue: true }, - }, - ast: "_==_(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n null~null\n ]~list(null),\n [\n null~null\n ]~list(null)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_list_null", - expr: "['1', '2', null] == ['1', '2', '3']", - value: { boolValue: false }, - }, - ast: '_==_(\n [\n "1"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n "1"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#,\n "3"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n [\n "1"~string,\n "2"~string,\n null~null\n ]~list(dyn),\n [\n "1"~string,\n "2"~string,\n "3"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_list_numbers", - expr: "[1, 2, 3] == [1, 2, 3]", - value: { boolValue: true }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_list_mixed_type_numbers", - expr: "[1.0, 2.0, 3] == [1u, 2, 3u]", - value: { boolValue: true }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n 1~double,\n 2~double,\n 3~int\n ]~list(dyn),\n [\n 1u~uint,\n 2~int,\n 3u~uint\n ]~list(dyn)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_list_mixed_type_numbers", - expr: "[1.0, 2.1] == [1u, 2]", - value: { boolValue: false }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2.1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n 1~double,\n 2.1~double\n ]~list(double),\n [\n 1u~uint,\n 2~int\n ]~list(dyn)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_list_order", - expr: "[1, 2, 3] == [1, 3, 2]", - value: { boolValue: false }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 3~int,\n 2~int\n ]~list(int)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_list_string_case", - expr: "['case'] == ['cAse']", - value: { boolValue: false }, - }, - ast: '_==_(\n [\n "case"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n "cAse"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n [\n "case"~string\n ]~list(string),\n [\n "cAse"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_list_length", - expr: "['one'] == [2, 3]", - disableCheck: true, - value: { boolValue: false }, - }, - ast: '_==_(\n [\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_==_' applied to '(list(string), list(int))'\n | ['one'] == [2, 3]\n | ........^", - }, - { - original: { - name: "not_eq_list_false_vs_types", - expr: "[1, 'dos', 3] == [1, 2, 4]", - value: { boolValue: false }, - }, - ast: '_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n "dos"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n [\n 1~int,\n "dos"~string,\n 3~int\n ]~list(dyn),\n [\n 1~int,\n 2~int,\n 4~int\n ]~list(int)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_map_empty", - expr: "{} == {}", - value: { boolValue: true }, - }, - ast: "_==_(\n {}^#*expr.Expr_StructExpr#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n {}~map(dyn, dyn),\n {}~map(dyn, dyn)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_map_null", - expr: "{'k': null} == {'k': null}", - value: { boolValue: true }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:null~null\n }~map(string, null),\n {\n "k"~string:null~null\n }~map(string, null)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_map_null", - expr: "{'k': 1, 'j': 2} == {'k': 1, 'j': null}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "j"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "j"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:1~int,\n "j"~string:2~int\n }~map(string, int),\n {\n "k"~string:1~int,\n "j"~string:null~null\n }~map(string, dyn)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_map_onekey", - expr: "{'k':'v'} == {\"k\":\"v\"}", - value: { boolValue: true }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:"v"~string\n }~map(string, string),\n {\n "k"~string:"v"~string\n }~map(string, string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_map_double_value", - expr: "{'k':1.0} == {'k':1e+0}", - value: { boolValue: true }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:1~double\n }~map(string, double),\n {\n "k"~string:1~double\n }~map(string, double)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_map_mixed_type_numbers", - expr: "{1: 1.0, 2u: 3u} == {1u: 1, 2: 3.0}", - value: { boolValue: true }, - }, - ast: "_==_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n {\n 1~int:1~double,\n 2u~uint:3u~uint\n }~map(dyn, dyn),\n {\n 1u~uint:1~int,\n 2~int:3~double\n }~map(dyn, dyn)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_map_value", - expr: "{'k':'v'} == {'k':'v1'}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:"v"~string\n }~map(string, string),\n {\n "k"~string:"v1"~string\n }~map(string, string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_map_extra_key", - expr: "{'k':'v','k1':'v1'} == {'k':'v'}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:"v"~string,\n "k1"~string:"v1"~string\n }~map(string, string),\n {\n "k"~string:"v"~string\n }~map(string, string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_map_key_order", - expr: "{'k1':'v1','k2':'v2'} == {'k2':'v2','k1':'v1'}", - value: { boolValue: true }, - }, - ast: '_==_(\n {\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k2"^#*expr.Constant_StringValue#:"v2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k2"^#*expr.Constant_StringValue#:"v2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k1"~string:"v1"~string,\n "k2"~string:"v2"~string\n }~map(string, string),\n {\n "k2"~string:"v2"~string,\n "k1"~string:"v1"~string\n }~map(string, string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_map_key_casing", - expr: "{'key':'value'} == {'Key':'value'}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n "key"^#*expr.Constant_StringValue#:"value"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "Key"^#*expr.Constant_StringValue#:"value"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "key"~string:"value"~string\n }~map(string, string),\n {\n "Key"~string:"value"~string\n }~map(string, string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_map_false_vs_types", - expr: "{'k1': 1, 'k2': 'dos', 'k3': 3} == {'k1': 1, 'k2': 2, 'k3': 4}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n "k1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "k2"^#*expr.Constant_StringValue#:"dos"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k3"^#*expr.Constant_StringValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "k2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "k3"^#*expr.Constant_StringValue#:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k1"~string:1~int,\n "k2"~string:"dos"~string,\n "k3"~string:3~int\n }~map(string, dyn),\n {\n "k1"~string:1~int,\n "k2"~string:2~int,\n "k3"~string:4~int\n }~map(string, int)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_mixed_types", - expr: "1.0 == 1", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(double, int)'\n | 1.0 == 1\n | ....^", - }, - { - original: { - name: "eq_list_elem_mixed_types", - expr: "[1] == [1.0]", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(list(int), list(double))'\n | [1] == [1.0]\n | ....^", - }, - { - original: { - name: "eq_map_value_mixed_types", - expr: "{'k':'v', 1:1} == {'k':'v', 1:'v1'}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n "k"~string:"v"~string,\n 1~int:1~int\n }~map(dyn, dyn),\n {\n "k"~string:"v"~string,\n 1~int:"v1"~string\n }~map(dyn, string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_dyn_json_null", - expr: "dyn(google.protobuf.Value{}) == null", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n google.protobuf.Value{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n google.protobuf.Value{}~dyn^google.protobuf.Value\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_bool_null", - expr: "dyn(false) == null", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n false~bool\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_bytes_null", - expr: "dyn(b'') == null", - value: { boolValue: false }, - }, - ast: '_==_(\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n dyn(\n b""~bytes\n )~dyn^to_dyn,\n null~null\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_dyn_double_null", - expr: "dyn(2.1) == null", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 2.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 2.1~double\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_duration_null", - expr: "dyn(duration('0s')) == null", - value: { boolValue: false }, - }, - ast: '_==_(\n dyn(\n duration(\n "0s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n dyn(\n duration(\n "0s"~string\n )~duration^string_to_duration\n )~dyn^to_dyn,\n null~null\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_dyn_int_null", - expr: "dyn(1) == null", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_list_null", - expr: "dyn([]) == null", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_map_null", - expr: "dyn({}) == null", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n {}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n {}~map(dyn, dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_proto2_msg_null", - expr: "dyn(TestAllTypes{}) == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_proto3_msg_null", - expr: "dyn(TestAllTypes{}) == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_string_null", - expr: "dyn('') == null", - value: { boolValue: false }, - }, - ast: '_==_(\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n dyn(\n ""~string\n )~dyn^to_dyn,\n null~null\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "not_eq_dyn_timestamp_null", - expr: "dyn(timestamp(0)) == null", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n timestamp(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n timestamp(\n 0~int\n )~timestamp^int64_to_timestamp\n )~dyn^to_dyn,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_list_elem_null", - expr: "[1, 2, null] == [1, null, 3]", - value: { boolValue: false }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n 1~int,\n 2~int,\n null~null\n ]~list(dyn),\n [\n 1~int,\n null~null,\n 3~int\n ]~list(dyn)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_map_value_null", - expr: "{1:'hello', 2:'world'} == {1:'goodbye', 2:null}", - value: { boolValue: false }, - }, - ast: '_==_(\n {\n 1^#*expr.Constant_Int64Value#:"hello"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:"world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n {\n 1~int:"hello"~string,\n 2~int:"world"~string\n }~map(int, string),\n {\n 1~int:"goodbye"~string,\n 2~int:null~null\n }~map(int, dyn)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_dyn_int_uint", - expr: "dyn(1) == 1u", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_dyn_int_double", - expr: "dyn(1) == 1.0", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_dyn_uint_int", - expr: "dyn(1u) == 1", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_dyn_uint_double", - expr: "dyn(1u) == 1.0", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_dyn_double_int", - expr: "dyn(1.0) == 1", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_dyn_double_uint", - expr: "dyn(1.0) == 1u", - value: { boolValue: true }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_int_uint", - expr: "dyn(1) == 2u", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_int_double", - expr: "dyn(1) == 2.0", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_uint_int", - expr: "dyn(1u) == 2", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_uint_double", - expr: "dyn(1u) == 120", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 120^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 120~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_double_int", - expr: "dyn(1.0) == 2", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_eq_dyn_double_uint", - expr: "dyn(1.0) == 2u", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "eq_wrapper", - tests: [ - { - original: { - name: "eq_bool", - expr: "google.protobuf.BoolValue{value: true} == true", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue,\n true~bool\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bool_empty", - expr: "google.protobuf.BoolValue{} == false", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n false~bool\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bool_not_null", - expr: "google.protobuf.BoolValue{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_bool_proto2_null", - expr: "TestAllTypes{}.single_bool_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bool_proto3_null", - expr: "TestAllTypes{}.single_bool_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bytes", - expr: "google.protobuf.BytesValue{value: b'set'} == b'set'", - value: { boolValue: true }, - }, - ast: '_==_(\n google.protobuf.BytesValue{\n value:b"set"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n b"set"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n google.protobuf.BytesValue{\n value:b"set"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue,\n b"set"~bytes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_bytes_empty", - expr: "google.protobuf.BytesValue{} == b''", - value: { boolValue: true }, - }, - ast: '_==_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n b""~bytes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_bytes_not_null", - expr: "google.protobuf.BytesValue{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_bytes_proto2_null", - expr: "TestAllTypes{}.single_bytes_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_bytes_proto3_null", - expr: "TestAllTypes{}.single_bytes_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double", - expr: "google.protobuf.DoubleValue{value: -1.175494e-40} == -1.175494e-40", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.175494e-40^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40~double\n }~wrapper(double)^google.protobuf.DoubleValue,\n -1.175494e-40~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double_empty", - expr: "google.protobuf.DoubleValue{} == 0.0", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n 0~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double_not_null", - expr: "google.protobuf.DoubleValue{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_double_proto2_null", - expr: "TestAllTypes{}.single_double_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_double_proto3_null", - expr: "TestAllTypes{}.single_double_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_float", - expr: "google.protobuf.FloatValue{value: -1.5} == -1.5", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.FloatValue{\n value:-1.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{\n value:-1.5~double\n }~wrapper(double)^google.protobuf.FloatValue,\n -1.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_float_empty", - expr: "google.protobuf.FloatValue{} == 0.0", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n 0~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_float_not_null", - expr: "google.protobuf.FloatValue{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_float_proto2_null", - expr: "TestAllTypes{}.single_float_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_float_proto3_null", - expr: "TestAllTypes{}.single_float_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int32", - expr: "google.protobuf.Int32Value{value: 123} == 123", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.Int32Value{\n value:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int32Value{\n value:123~int\n }~wrapper(int)^google.protobuf.Int32Value,\n 123~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int32_empty", - expr: "google.protobuf.Int32Value{} == 0", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n 0~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int32_not_null", - expr: "google.protobuf.Int32Value{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_int32_proto2_null", - expr: "TestAllTypes{}.single_int32_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int32_proto3_null", - expr: "TestAllTypes{}.single_int32_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int64", - expr: "google.protobuf.Int64Value{value: 2147483650} == 2147483650", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.Int64Value{\n value:2147483650^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2147483650^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int64Value{\n value:2147483650~int\n }~wrapper(int)^google.protobuf.Int64Value,\n 2147483650~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int64_empty", - expr: "google.protobuf.Int64Value{} == 0", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n 0~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int64_not_null", - expr: "google.protobuf.Int64Value{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_int64_proto2_null", - expr: "TestAllTypes{}.single_int64_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_int64_proto3_null", - expr: "TestAllTypes{}.single_int64_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_string", - expr: "google.protobuf.StringValue{value: 'set'} == 'set'", - value: { boolValue: true }, - }, - ast: '_==_(\n google.protobuf.StringValue{\n value:"set"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "set"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n google.protobuf.StringValue{\n value:"set"~string\n }~wrapper(string)^google.protobuf.StringValue,\n "set"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_string_empty", - expr: "google.protobuf.StringValue{} == ''", - value: { boolValue: true }, - }, - ast: '_==_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n ""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_string_not_null", - expr: "google.protobuf.StringValue{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_string_proto2_null", - expr: "TestAllTypes{}.single_string_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_string_proto3_null", - expr: "TestAllTypes{}.single_string_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint32", - expr: "google.protobuf.UInt32Value{value: 42u} == 42u", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.UInt32Value{\n value:42u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt32Value{\n value:42u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n 42u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint32_empty", - expr: "google.protobuf.UInt32Value{} == 0u", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n 0u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint32_not_null", - expr: "google.protobuf.UInt32Value{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_uint32_proto2_null", - expr: "TestAllTypes{}.single_uint32_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint32_proto3_null", - expr: "TestAllTypes{}.single_uint32_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint64", - expr: "google.protobuf.UInt64Value{value: 4294967296u} == 4294967296u", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.UInt64Value{\n value:4294967296u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 4294967296u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt64Value{\n value:4294967296u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value,\n 4294967296u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint64_empty", - expr: "google.protobuf.UInt64Value{} == 0u", - value: { boolValue: true }, - }, - ast: "_==_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n 0u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint64_not_null", - expr: "google.protobuf.UInt64Value{} != null", - value: { boolValue: true }, - }, - ast: "_!=_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "eq_uint64_proto2_null", - expr: "TestAllTypes{}.single_uint64_wrapper == null", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_uint64_proto3_null", - expr: "TestAllTypes{}.single_uint64_wrapper == null", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_proto2", - expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto3", - expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto2_missing_fields_neq", - expr: "TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto3_missing_fields_neq", - expr: "TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto_nan_equal", - description: - "For proto equality, fields with NaN value are treated as not equal.", - expr: "TestAllTypes{single_double: double('NaN')} == TestAllTypes{single_double: double('NaN')}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto_different_types", - description: - "At runtime, differently typed messages are treated as not equal.", - expr: "dyn(TestAllTypes{}) == dyn(NestedTestAllTypes{})", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "eq_proto2_any_unpack_equal", - description: "Any values should be unpacked and compared.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto2_any_unpack_not_equal", - description: "Any values should be unpacked and compared.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto2_any_unpack_bytewise_fallback_not_equal", - description: - "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto2_any_unpack_bytewise_fallback_equal", - description: - "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto3_any_unpack_equal", - description: "Any values should be unpacked and compared.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto3_any_unpack_not_equal", - description: "Any values should be unpacked and compared.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto3_any_unpack_bytewise_fallback_not_equal", - description: - "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_proto3_any_unpack_bytewise_fallback_equal", - description: - "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "ne_literal", - tests: [ - { - original: { - name: "ne_int", - expr: "24 != 42", - value: { boolValue: true }, - }, - ast: "_!=_(\n 24^#*expr.Constant_Int64Value#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n 24~int,\n 42~int\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_int", - expr: "1 != 1", - value: { boolValue: false }, - }, - ast: "_!=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n 1~int,\n 1~int\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_int_double", - expr: "dyn(24) != 24.1", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 24.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 24.1~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_int_double", - expr: "dyn(1) != 1.0", - value: { boolValue: false }, - }, - ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_int_uint", - expr: "dyn(24) != 42u", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 42u~uint\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_int_uint", - expr: "dyn(1) != 1u", - value: { boolValue: false }, - }, - ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_uint", - expr: "1u != 2u", - value: { boolValue: true }, - }, - ast: "_!=_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n 1u~uint,\n 2u~uint\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_uint", - expr: "99u != 99u", - value: { boolValue: false }, - }, - ast: "_!=_(\n 99u^#*expr.Constant_Uint64Value#,\n 99u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n 99u~uint,\n 99u~uint\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_uint_double", - expr: "dyn(1u) != 2.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_uint_double", - expr: "dyn(99u) != 99.0", - value: { boolValue: false }, - }, - ast: "_!=_(\n dyn(\n 99u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 99u~uint\n )~dyn^to_dyn,\n 99~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_double", - expr: "9.0e+3 != 9001.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n 9000^#*expr.Constant_DoubleValue#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n 9000~double,\n 9001~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_double_nan", - expr: "0.0/0.0 != 0.0/0.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_int_double_nan", - expr: "dyn(1) != 0.0/0.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_uint_double_nan", - expr: "dyn(1u) != 0.0/0.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_double", - expr: "1.0 != 1e+0", - value: { boolValue: false }, - }, - ast: "_!=_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n 1~double,\n 1~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_double_int", - expr: "dyn(9000) != 9001.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 9000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 9000~int\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_double_int", - expr: "dyn(1) != 1e+0", - value: { boolValue: false }, - }, - ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_double_uint", - expr: "dyn(9000u) != 9001.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n 9000u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 9000u~uint\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_double_uint", - expr: "dyn(1u) != 1e+0", - value: { boolValue: false }, - }, - ast: "_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_double_nan", - expr: "0.0/0.0 != 0.0/0.0", - value: { boolValue: true }, - }, - ast: "_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_string", - expr: "'abc' != ''", - value: { boolValue: true }, - }, - ast: '_!=_(\n "abc"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n "abc"~string,\n ""~string\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "not_ne_string", - expr: "'abc' != 'abc'", - value: { boolValue: false }, - }, - ast: '_!=_(\n "abc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n "abc"~string,\n "abc"~string\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_string_unicode", - expr: "'résumé' != 'resume'", - value: { boolValue: true }, - }, - ast: '_!=_(\n "résumé"^#*expr.Constant_StringValue#,\n "resume"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n "résumé"~string,\n "resume"~string\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "not_ne_string_unicode", - expr: "'ίδιο' != 'ίδιο'", - value: { boolValue: false }, - }, - ast: '_!=_(\n "ίδιο"^#*expr.Constant_StringValue#,\n "ίδιο"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n "ίδιο"~string,\n "ίδιο"~string\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_bytes", - expr: "b'\\x00\\xFF' != b'ÿ'", - value: { boolValue: true }, - }, - ast: '_!=_(\n b"\\x00\\xff"^#*expr.Constant_BytesValue#,\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n b"\\x00\\xff"~bytes,\n b"ÿ"~bytes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "not_ne_bytes", - expr: "b'\\303\\277' != b'ÿ'", - value: { boolValue: false }, - }, - ast: '_!=_(\n b"ÿ"^#*expr.Constant_BytesValue#,\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n b"ÿ"~bytes,\n b"ÿ"~bytes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_bool", - expr: "false != true", - value: { boolValue: true }, - }, - ast: "_!=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n false~bool,\n true~bool\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_bool", - expr: "true != true", - value: { boolValue: false }, - }, - ast: "_!=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n true~bool,\n true~bool\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_null", - description: - "null can only be equal to null, or else it won't match", - expr: "null != null", - value: { boolValue: false }, - }, - ast: "_!=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_!=_(\n null~null,\n null~null\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_list_empty", - expr: "[] != [1]", - value: { boolValue: true }, - }, - ast: "_!=_(\n []^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n []~list(int),\n [\n 1~int\n ]~list(int)\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_list_empty", - expr: "[] != []", - value: { boolValue: false }, - }, - ast: "_!=_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n []~list(dyn),\n []~list(dyn)\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_list_bool", - expr: "[true, false, true] != [true, true, false]", - value: { boolValue: true }, - }, - ast: "_!=_(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n [\n true~bool,\n false~bool,\n true~bool\n ]~list(bool),\n [\n true~bool,\n true~bool,\n false~bool\n ]~list(bool)\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_list_bool", - expr: "[false, true] != [false, true]", - value: { boolValue: false }, - }, - ast: "_!=_(\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n [\n false~bool,\n true~bool\n ]~list(bool),\n [\n false~bool,\n true~bool\n ]~list(bool)\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_list_of_list", - expr: "[[]] != [[]]", - value: { boolValue: false }, - }, - ast: "_!=_(\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n [\n []~list(dyn)\n ]~list(list(dyn)),\n [\n []~list(dyn)\n ]~list(list(dyn))\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_map_by_value", - expr: "{'k':'v'} != {'k':'v1'}", - value: { boolValue: true }, - }, - ast: '_!=_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n {\n "k"~string:"v"~string\n }~map(string, string),\n {\n "k"~string:"v1"~string\n }~map(string, string)\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_map_by_key", - expr: "{'k':true} != {'k1':true}", - value: { boolValue: true }, - }, - ast: '_!=_(\n {\n "k"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k1"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n {\n "k"~string:true~bool\n }~map(string, bool),\n {\n "k1"~string:true~bool\n }~map(string, bool)\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "not_ne_map_int_to_float", - expr: "{1:1.0} != {1:1.0}", - value: { boolValue: false }, - }, - ast: "_!=_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n {\n 1~int:1~double\n }~map(int, double),\n {\n 1~int:1~double\n }~map(int, double)\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "not_ne_map_key_order", - expr: "{'a':'b','c':'d'} != {'c':'d','a':'b'}", - value: { boolValue: false }, - }, - ast: '_!=_(\n {\n "a"^#*expr.Constant_StringValue#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "c"^#*expr.Constant_StringValue#:"d"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "c"^#*expr.Constant_StringValue#:"d"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "a"^#*expr.Constant_StringValue#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n {\n "a"~string:"b"~string,\n "c"~string:"d"~string\n }~map(string, string),\n {\n "c"~string:"d"~string,\n "a"~string:"b"~string\n }~map(string, string)\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_mixed_types", - expr: "2u != 2", - disableCheck: true, - value: { boolValue: false }, - }, - ast: "_!=_(\n 2u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:4: found no matching overload for '_!=_' applied to '(uint, int)'\n | 2u != 2\n | ...^", - }, - { - original: { - name: "ne_proto2", - expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto3", - expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto2_missing_fields_neq", - expr: "TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto3_missing_fields_neq", - expr: "TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto_nan_not_equal", - description: - "For proto equality, NaN field values are not considered equal.", - expr: "TestAllTypes{single_double: double('NaN')} != TestAllTypes{single_double: double('NaN')}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: '_!=_(\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto_different_types", - description: - "At runtime, comparing differently typed messages is false.", - expr: "dyn(TestAllTypes{}) != dyn(NestedTestAllTypes{})", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_!=_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "ne_proto2_any_unpack", - description: "Any values should be unpacked and compared.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto2_any_unpack_bytewise_fallback", - description: - "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto3_any_unpack", - description: "Any values should be unpacked and compared.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "ne_proto3_any_unpack_bytewise_fallback", - description: - "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", - expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', - type: "bool", - }, - ], - }, - { - name: "lt_literal", - tests: [ - { - original: { - name: "lt_int", - expr: "-1 \u003c 0", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n -1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_\u003c_(\n -1~int,\n 0~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "not_lt_int", - expr: "0 \u003c 0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_\u003c_(\n 0~int,\n 0~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "lt_uint", - expr: "0u \u003c 1u", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n 0u~uint,\n 1u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "not_lt_uint", - expr: "2u \u003c 2u", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n 2u~uint,\n 2u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "lt_double", - expr: "1.0 \u003c 1.0000001", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n 1^#*expr.Constant_DoubleValue#,\n 1.0000001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n 1~double,\n 1.0000001~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_double", - description: - "Following IEEE 754, negative zero compares equal to zero", - expr: "-0.0 \u003c 0.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n -0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n -0~double,\n 0~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "lt_string", - expr: "'a' \u003c 'b'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n "a"^#*expr.Constant_StringValue#,\n "b"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "a"~string,\n "b"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "lt_string_empty_to_nonempty", - expr: "'' \u003c 'a'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n ""^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n ""~string,\n "a"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "lt_string_case", - expr: "'Abc' \u003c 'aBC'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n "Abc"^#*expr.Constant_StringValue#,\n "aBC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "Abc"~string,\n "aBC"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "lt_string_length", - expr: "'abc' \u003c 'abcd'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n "abc"^#*expr.Constant_StringValue#,\n "abcd"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "abc"~string,\n "abcd"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "lt_string_diacritical_mark_sensitive", - description: - "Verifies that the we're not using a string comparison function that strips diacritical marks (á)", - expr: "'a' \u003c '\\u00E1'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n "a"^#*expr.Constant_StringValue#,\n "á"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "a"~string,\n "á"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "not_lt_string_empty", - expr: "'' \u003c ''", - value: { boolValue: false }, - }, - ast: '_\u003c_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n ""~string,\n ""~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "not_lt_string_same", - expr: "'abc' \u003c 'abc'", - value: { boolValue: false }, - }, - ast: '_\u003c_(\n "abc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "abc"~string,\n "abc"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "not_lt_string_case_length", - expr: "'a' \u003c 'AB'", - value: { boolValue: false }, - }, - ast: '_\u003c_(\n "a"^#*expr.Constant_StringValue#,\n "AB"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "a"~string,\n "AB"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "unicode_order_lexical", - description: - "Compare the actual code points of the string, instead of decomposing ế into 'e' plus accent modifiers.", - expr: "'f' \u003c '\\u1EBF'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n "f"^#*expr.Constant_StringValue#,\n "ế"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n "f"~string,\n "ế"~string\n)~bool^less_string', - type: "bool", - }, - { - original: { - name: "lt_bytes", - expr: "b'a' \u003c b'b'", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n b"a"^#*expr.Constant_BytesValue#,\n b"b"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n b"a"~bytes,\n b"b"~bytes\n)~bool^less_bytes', - type: "bool", - }, - { - original: { - name: "not_lt_bytes_same", - expr: "b'abc' \u003c b'abc'", - value: { boolValue: false }, - }, - ast: '_\u003c_(\n b"abc"^#*expr.Constant_BytesValue#,\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n b"abc"~bytes,\n b"abc"~bytes\n)~bool^less_bytes', - type: "bool", - }, - { - original: { - name: "not_lt_bytes_width", - expr: "b'á' \u003c b'b'", - value: { boolValue: false }, - }, - ast: '_\u003c_(\n b"á"^#*expr.Constant_BytesValue#,\n b"b"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n b"á"~bytes,\n b"b"~bytes\n)~bool^less_bytes', - type: "bool", - }, - { - original: { - name: "lt_bool_false_first", - expr: "false \u003c true", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n false~bool,\n true~bool\n)~bool^less_bool", - type: "bool", - }, - { - original: { - name: "not_lt_bool_same", - expr: "true \u003c true", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n true~bool,\n true~bool\n)~bool^less_bool", - type: "bool", - }, - { - original: { - name: "not_lt_bool_true_first", - expr: "true \u003c false", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n true~bool,\n false~bool\n)~bool^less_bool", - type: "bool", - }, - { - original: { - name: "lt_list_unsupported", - expr: "[0] \u003c [1]", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003c_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c_' applied to '(list(int), list(int))'\n | [0] \u003c [1]\n | ....^", - }, - { - original: { - name: "lt_map_unsupported", - expr: "{0:'a'} \u003c {1:'b'}", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003c_(\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c {1:'b'}\n | ........^", - }, - { - original: { - name: "lt_null_unsupported", - description: "Ensure _\u003c_ doesn't have a binding for null", - expr: "null \u003c null", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003c_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n null~null,\n null~null\n)~bool^less_duration|less_timestamp", - type: "bool", - }, - { - original: { - name: "lt_mixed_types_error", - expr: "'foo' \u003c 1024", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003c_(\n "foo"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c_' applied to '(string, int)'\n | 'foo' \u003c 1024\n | ......^", - }, - { - original: { - name: "lt_dyn_int_uint", - expr: "dyn(1) \u003c 2u", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "lt_dyn_int_double", - expr: "dyn(1) \u003c 2.0", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "lt_dyn_uint_int", - expr: "dyn(1u) \u003c 2", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "lt_dyn_uint_double", - expr: "dyn(1u) \u003c 2.0", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "lt_dyn_double_int", - expr: "dyn(1.0) \u003c 2", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "lt_dyn_double_uint", - expr: "dyn(1.0) \u003c 2u", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_int_uint", - expr: "dyn(1) \u003c 1u", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_int_double", - expr: "dyn(1) \u003c 1.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_uint_int", - expr: "dyn(1u) \u003c 1", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_uint_double", - expr: "dyn(1u) \u003c 1.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_double_int", - expr: "dyn(1.0) \u003c 1", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_double_uint", - expr: "dyn(1.0) \u003c 1u", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "lt_dyn_int_big_uint", - expr: "dyn(1) \u003c 9223372036854775808u", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "lt_dyn_small_int_uint", - expr: "dyn(-1) \u003c 0u", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_int_big_lossy_double", - expr: "dyn(9223372036854775807) \u003c 9223372036854775808.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "lt_dyn_int_big_lossy_double", - expr: "dyn(9223372036854775807) \u003c 9223372036854777857.0", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_int_small_double", - expr: "dyn(9223372036854775807) \u003c -9223372036854777857.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_int_small_lossy_double", - expr: "dyn(-9223372036854775808) \u003c -9223372036854775809.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_uint_small_int", - expr: "dyn(1u) \u003c -9223372036854775808", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_big_uint_int", - expr: "dyn(9223372036854775808u) \u003c 1", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_uint_small_double", - expr: "dyn(18446744073709551615u) \u003c -1.0", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "lt_dyn_uint_big_double", - expr: "dyn(18446744073709551615u) \u003c 18446744073709590000.0", - value: { boolValue: true }, - }, - ast: "_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_double", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_big_double_uint", - expr: "dyn(18446744073709553665.0) \u003c 18446744073709551615u", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_uint64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_big_double_int", - expr: "dyn(9223372036854775808.0) \u003c 9223372036854775807", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_int64", - type: "bool", - }, - { - original: { - name: "not_lt_dyn_small_double_int", - expr: "dyn(-9223372036854775809.0) \u003c -9223372036854775808", - value: { boolValue: false }, - }, - ast: "_\u003c_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64", - type: "bool", - }, - ], - }, - { - name: "gt_literal", - tests: [ - { - original: { - name: "gt_int", - expr: "42 \u003e -42", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n 42^#*expr.Constant_Int64Value#,\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n 42~int,\n -42~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "not_gt_int", - expr: "0 \u003e 0", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_\u003e_(\n 0~int,\n 0~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "gt_uint", - expr: "48u \u003e 46u", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n 48u^#*expr.Constant_Uint64Value#,\n 46u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n 48u~uint,\n 46u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_uint", - expr: "0u \u003e 999u", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n 0u^#*expr.Constant_Uint64Value#,\n 999u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n 0u~uint,\n 999u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "gt_double", - expr: "1e+1 \u003e 1e+0", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n 10~double,\n 1~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "not_gt_double", - expr: ".99 \u003e 9.9e-1", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n 0.99^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n 0.99~double,\n 0.99~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "gt_string_case", - expr: "'abc' \u003e 'aBc'", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n "abc"^#*expr.Constant_StringValue#,\n "aBc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n "abc"~string,\n "aBc"~string\n)~bool^greater_string', - type: "bool", - }, - { - original: { - name: "gt_string_to_empty", - expr: "'A' \u003e ''", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n "A"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n "A"~string,\n ""~string\n)~bool^greater_string', - type: "bool", - }, - { - original: { - name: "not_gt_string_empty_to_empty", - expr: "'' \u003e ''", - value: { boolValue: false }, - }, - ast: '_\u003e_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n ""~string,\n ""~string\n)~bool^greater_string', - type: "bool", - }, - { - original: { - name: "gt_string_unicode", - expr: "'α' \u003e 'omega'", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n "α"^#*expr.Constant_StringValue#,\n "omega"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n "α"~string,\n "omega"~string\n)~bool^greater_string', - type: "bool", - }, - { - original: { - name: "gt_bytes_one", - expr: "b'\u0001' \u003e b'\u0000'", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n b"\\x01"^#*expr.Constant_BytesValue#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n b"\\x01"~bytes,\n b"\\x00"~bytes\n)~bool^greater_bytes', - type: "bool", - }, - { - original: { - name: "gt_bytes_one_to_empty", - expr: "b'\u0000' \u003e b''", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n b"\\x00"^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n b"\\x00"~bytes,\n b""~bytes\n)~bool^greater_bytes', - type: "bool", - }, - { - original: { - name: "not_gt_bytes_sorting", - expr: "b'\u0000\u0001' \u003e b'\u0001'", - value: { boolValue: false }, - }, - ast: '_\u003e_(\n b"\\x00\\x01"^#*expr.Constant_BytesValue#,\n b"\\x01"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n b"\\x00\\x01"~bytes,\n b"\\x01"~bytes\n)~bool^greater_bytes', - type: "bool", - }, - { - original: { - name: "gt_bool_true_false", - expr: "true \u003e false", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n true~bool,\n false~bool\n)~bool^greater_bool", - type: "bool", - }, - { - original: { - name: "not_gt_bool_false_true", - expr: "false \u003e true", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n false~bool,\n true~bool\n)~bool^greater_bool", - type: "bool", - }, - { - original: { - name: "not_gt_bool_same", - expr: "true \u003e true", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n true~bool,\n true~bool\n)~bool^greater_bool", - type: "bool", - }, - { - original: { - name: "gt_null_unsupported", - expr: "null \u003e null", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003e_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n null~null,\n null~null\n)~bool^greater_duration|greater_timestamp", - type: "bool", - }, - { - original: { - name: "gt_list_unsupported", - expr: "[1] \u003e [0]", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003e_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003e_' applied to '(list(int), list(int))'\n | [1] \u003e [0]\n | ....^", - }, - { - original: { - name: "gt_map_unsupported", - expr: "{1:'b'} \u003e {0:'a'}", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003e_(\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e {0:'a'}\n | ........^", - }, - { - original: { - name: "gt_mixed_types_error", - expr: "'foo' \u003e 1024", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003e_(\n "foo"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e_' applied to '(string, int)'\n | 'foo' \u003e 1024\n | ......^", - }, - { - original: { - name: "gt_dyn_int_uint", - expr: "dyn(2) \u003e 1u", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "gt_dyn_int_double", - expr: "dyn(2) \u003e 1.0", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "gt_dyn_uint_int", - expr: "dyn(2u) \u003e 1", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "gt_dyn_uint_double", - expr: "dyn(2u) \u003e 1.0", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "gt_dyn_double_int", - expr: "dyn(2.0) \u003e 1", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "gt_dyn_double_uint", - expr: "dyn(2.0) \u003e 1u", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_int_uint", - expr: "dyn(1) \u003e 1u", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_int_double", - expr: "dyn(1) \u003e 1.0", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_uint_int", - expr: "dyn(1u) \u003e 1", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_uint_double", - expr: "dyn(1u) \u003e 1.0", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_double_int", - expr: "dyn(1.0) \u003e 1", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_double_uint", - expr: "dyn(1.0) \u003e 1u", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_int_big_uint", - expr: "dyn(1) \u003e 9223372036854775808u", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_small_int_uint", - expr: "dyn(-1) \u003e 0u", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_int_big_double", - expr: "dyn(9223372036854775807) \u003e 9223372036854775808.0", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_int_small_lossy_double", - description: - "The conversion of the int to double is lossy and the numbers end up being equal", - expr: "dyn(-9223372036854775808) \u003e -9223372036854775809.0", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "gt_dyn_int_small_lossy_double_greater", - expr: "dyn(-9223372036854775808) \u003e -9223372036854777857.0", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "gt_dyn_uint_small_int", - expr: "dyn(1u) \u003e -1", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "gt_dyn_big_uint_int", - expr: "dyn(9223372036854775808u) \u003e 1", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "gt_dyn_uint_small_double", - expr: "dyn(9223372036854775807u) \u003e -1.0", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_uint_big_double", - expr: "dyn(18446744073709551615u) \u003e 18446744073709590000.0", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^greater_double", - type: "bool", - }, - { - original: { - name: "gt_dyn_big_double_uint", - expr: "dyn(18446744073709553665.0) \u003e 18446744073709551615u", - value: { boolValue: true }, - }, - ast: "_\u003e_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_uint64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_big_double_int", - expr: "dyn(9223372036854775808.0) \u003e 9223372036854775807", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_int64", - type: "bool", - }, - { - original: { - name: "not_gt_dyn_small_double_int", - expr: "dyn(-9223372036854775809.0) \u003e -9223372036854775808", - value: { boolValue: false }, - }, - ast: "_\u003e_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_int64", - type: "bool", - }, - ], - }, - { - name: "lte_literal", - tests: [ - { - original: { - name: "lte_int_lt", - expr: "0 \u003c= 1", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 0~int,\n 1~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "lte_int_eq", - expr: "1 \u003c= 1", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 1~int,\n 1~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "not_lte_int_gt", - expr: "1 \u003c= -1", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 1~int,\n -1~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "lte_uint_lt", - expr: "0u \u003c= 1u", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 0u~uint,\n 1u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_uint_eq", - expr: "1u \u003c= 1u", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 1u~uint,\n 1u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_lte_uint_gt", - expr: "1u \u003c= 0u", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 1u~uint,\n 0u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_double_lt", - expr: "0.0 \u003c= 0.1e-31", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 1e-32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 0~double,\n 1e-32~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "lte_double_eq", - expr: "0.0 \u003c= 0e-1", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 0~double,\n 0~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "not_lte_double_gt", - expr: "1.0 \u003c= 0.99", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n 1^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 1~double,\n 0.99~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "lte_string_empty", - expr: "'' \u003c= ''", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n ""~string,\n ""~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "lte_string_from_empty", - expr: "'' \u003c= 'a'", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n ""^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n ""~string,\n "a"~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "not_lte_string_to_empty", - expr: "'a' \u003c= ''", - value: { boolValue: false }, - }, - ast: '_\u003c=_(\n "a"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n "a"~string,\n ""~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "lte_string_lexicographical", - expr: "'aBc' \u003c= 'abc'", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n "aBc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n "aBc"~string,\n "abc"~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "lte_string_unicode_eq", - expr: "'α' \u003c= 'α'", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n "α"^#*expr.Constant_StringValue#,\n "α"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n "α"~string,\n "α"~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "lte_string_unicode_lt", - expr: "'a' \u003c= 'α'", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n "a"^#*expr.Constant_StringValue#,\n "α"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n "a"~string,\n "α"~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "not_lte_string_unicode", - expr: "'α' \u003c= 'a'", - value: { boolValue: false }, - }, - ast: '_\u003c=_(\n "α"^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n "α"~string,\n "a"~string\n)~bool^less_equals_string', - type: "bool", - }, - { - original: { - name: "lte_bytes_empty", - expr: "b'' \u003c= b'\u0000'", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n b""^#*expr.Constant_BytesValue#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n b""~bytes,\n b"\\x00"~bytes\n)~bool^less_equals_bytes', - type: "bool", - }, - { - original: { - name: "not_lte_bytes_length", - expr: "b'\u0001\u0000' \u003c= b'\u0001'", - value: { boolValue: false }, - }, - ast: '_\u003c=_(\n b"\\x01\\x00"^#*expr.Constant_BytesValue#,\n b"\\x01"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n b"\\x01\\x00"~bytes,\n b"\\x01"~bytes\n)~bool^less_equals_bytes', - type: "bool", - }, - { - original: { - name: "lte_bool_false_true", - expr: "false \u003c= true", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n false~bool,\n true~bool\n)~bool^less_equals_bool", - type: "bool", - }, - { - original: { - name: "lte_bool_false_false", - expr: "false \u003c= false", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n false~bool,\n false~bool\n)~bool^less_equals_bool", - type: "bool", - }, - { - original: { - name: "lte_bool_true_false", - expr: "true \u003c= false", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n true~bool,\n false~bool\n)~bool^less_equals_bool", - type: "bool", - }, - { - original: { - name: "lte_null_unsupported", - expr: "null \u003c= null", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003c=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n null~null,\n null~null\n)~bool^less_equals_duration|less_equals_timestamp", - type: "bool", - }, - { - original: { - name: "lte_list_unsupported", - expr: "[0] \u003c= [0]", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003c=_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c=_' applied to '(list(int), list(int))'\n | [0] \u003c= [0]\n | ....^", - }, - { - original: { - name: "lte_map_unsupported", - expr: "{0:'a'} \u003c= {1:'b'}", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003c=_(\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c=_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c= {1:'b'}\n | ........^", - }, - { - original: { - name: "lte_mixed_types_error", - expr: "'foo' \u003c= 1024", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003c=_(\n "foo"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c=_' applied to '(string, int)'\n | 'foo' \u003c= 1024\n | ......^", - }, - { - original: { - name: "lte_dyn_int_uint", - expr: "dyn(1) \u003c= 2u", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_dyn_int_double", - expr: "dyn(1) \u003c= 2.0", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "lte_dyn_uint_int", - expr: "dyn(1u) \u003c= 2", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "lte_dyn_uint_double", - expr: "dyn(1u) \u003c= 2.0", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "lte_dyn_double_int", - expr: "dyn(1.0) \u003c= 2", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "lte_dyn_double_uint", - expr: "dyn(1.0) \u003c= 2u", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_int_uint", - expr: "dyn(2) \u003c= 1u", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_int_double", - expr: "dyn(2) \u003c= 1.0", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_uint_int", - expr: "dyn(2u) \u003c= 1", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_uint_double", - expr: "dyn(2u) \u003c= 1.0", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_double_int", - expr: "dyn(2.0) \u003c= 1", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_double_uint", - expr: "dyn(2.0) \u003c= 1u", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_dyn_int_big_uint", - expr: "dyn(1) \u003c= 9223372036854775808u", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_dyn_small_int_uint", - expr: "dyn(-1) \u003c= 0u", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_dyn_int_big_double", - expr: "dyn(9223372036854775807) \u003c= 9223372036854775808.0", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "lte_dyn_int_small_lossy_double", - description: - "The conversion of the int to double is lossy and the numbers end up being equal", - expr: "dyn(-9223372036854775808) \u003c= -9223372036854775809.0", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_int_small_lossy_double_less", - expr: "dyn(-9223372036854775808) \u003c= -9223372036854777857.0", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_uint_small_int", - expr: "dyn(1u) \u003c= -9223372036854775808", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_big_uint_int", - expr: "dyn(9223372036854775808u) \u003c= 1", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_uint_small_double", - expr: "dyn(18446744073709551615u) \u003c= -1.0", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "lte_dyn_uint_big_double", - expr: "dyn(18446744073709551615u) \u003c= 18446744073709590000.0", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_equals_double", - type: "bool", - }, - { - original: { - name: "not_lte_dyn_big_double_uint", - expr: "dyn(18446744073709553665.0) \u003c= 18446744073709551615u", - value: { boolValue: false }, - }, - ast: "_\u003c=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_equals_uint64", - type: "bool", - }, - { - original: { - name: "lte_dyn_big_double_int", - expr: "dyn(9223372036854775808.0) \u003c= 9223372036854775807", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "lte_dyn_small_double_int", - expr: "dyn(-9223372036854775809.0) \u003c= -9223372036854775808", - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64", - type: "bool", - }, - ], - }, - { - name: "gte_literal", - tests: [ - { - original: { - name: "gte_int_gt", - expr: "0 \u003e= -1", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n 0^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 0~int,\n -1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_int_eq", - expr: "999 \u003e= 999", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 999^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 999~int,\n 999~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "not_gte_int_lt", - expr: "999 \u003e= 1000", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 1000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 999~int,\n 1000~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_uint_gt", - expr: "1u \u003e= 0u", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 1u~uint,\n 0u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "gte_uint_eq", - expr: "0u \u003e= 0u", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n 0u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 0u~uint,\n 0u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_gte_uint_lt", - expr: "1u \u003e= 10u", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 1u~uint,\n 10u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "gte_double_gt", - expr: "1e+1 \u003e= 1e+0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 10~double,\n 1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_double_eq", - expr: "9.80665 \u003e= 9.80665e+0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n 9.80665^#*expr.Constant_DoubleValue#,\n 9.80665^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 9.80665~double,\n 9.80665~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "not_gte_double_lt", - expr: "0.9999 \u003e= 1.0", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n 0.9999^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n 0.9999~double,\n 1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_string_empty", - expr: "'' \u003e= ''", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n ""~string,\n ""~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "gte_string_to_empty", - expr: "'a' \u003e= ''", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n "a"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "a"~string,\n ""~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "gte_string_empty_to_nonempty", - expr: "'' \u003e= 'a'", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n ""^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n ""~string,\n "a"~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "gte_string_length", - expr: "'abcd' \u003e= 'abc'", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n "abcd"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "abcd"~string,\n "abc"~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "not_gte_string_lexicographical", - expr: "'abc' \u003e= 'abd'", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n "abc"^#*expr.Constant_StringValue#,\n "abd"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "abc"~string,\n "abd"~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "gte_string_unicode_eq", - expr: "'τ' \u003e= 'τ'", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n "τ"^#*expr.Constant_StringValue#,\n "τ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "τ"~string,\n "τ"~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "gte_string_unicode_gt", - expr: "'τ' \u003e= 't'", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n "τ"^#*expr.Constant_StringValue#,\n "t"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "τ"~string,\n "t"~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "not_get_string_unicode", - expr: "'t' \u003e= 'τ'", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n "t"^#*expr.Constant_StringValue#,\n "τ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "t"~string,\n "τ"~string\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "gte_bytes_to_empty", - expr: "b'\u0000' \u003e= b''", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n b"\\x00"^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n b"\\x00"~bytes,\n b""~bytes\n)~bool^greater_equals_bytes', - type: "bool", - }, - { - original: { - name: "not_gte_bytes_empty_to_nonempty", - expr: "b'' \u003e= b'\u0000'", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n b""^#*expr.Constant_BytesValue#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n b""~bytes,\n b"\\x00"~bytes\n)~bool^greater_equals_bytes', - type: "bool", - }, - { - original: { - name: "gte_bytes_samelength", - expr: "b'\u0000\u0001' \u003e= b'\u0001\u0000'", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n b"\\x00\\x01"^#*expr.Constant_BytesValue#,\n b"\\x01\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n b"\\x00\\x01"~bytes,\n b"\\x01\\x00"~bytes\n)~bool^greater_equals_bytes', - type: "bool", - }, - { - original: { - name: "gte_bool_gt", - expr: "true \u003e= false", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n true~bool,\n false~bool\n)~bool^greater_equals_bool", - type: "bool", - }, - { - original: { - name: "gte_bool_eq", - expr: "true \u003e= true", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n true~bool,\n true~bool\n)~bool^greater_equals_bool", - type: "bool", - }, - { - original: { - name: "not_gte_bool_lt", - expr: "false \u003e= true", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n false~bool,\n true~bool\n)~bool^greater_equals_bool", - type: "bool", - }, - { - original: { - name: "gte_null_unsupported", - expr: "null \u003e= null", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003e=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n null~null,\n null~null\n)~bool^greater_equals_duration|greater_equals_timestamp", - type: "bool", - }, - { - original: { - name: "gte_list_unsupported", - expr: "['y'] \u003e= ['x']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003e=_(\n [\n "y"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n "x"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(list(string), list(string))'\n | ['y'] \u003e= ['x']\n | ......^", - }, - { - original: { - name: "gte_map_unsupported", - expr: "{1:'b'} \u003e= {0:'a'}", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003e=_(\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e=_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e= {0:'a'}\n | ........^", - }, - { - original: { - name: "gte_mixed_types_error", - expr: "'foo' \u003e= 1.0", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_\u003e=_(\n "foo"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(string, double)'\n | 'foo' \u003e= 1.0\n | ......^", - }, - { - original: { - name: "gte_dyn_int_uint", - expr: "dyn(2) \u003e= 1u", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "gte_dyn_int_double", - expr: "dyn(2) \u003e= 1.0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_dyn_uint_int", - expr: "dyn(2u) \u003e= 1", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_dyn_uint_double", - expr: "dyn(2u) \u003e= 1.0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_dyn_double_int", - expr: "dyn(2.0) \u003e= 1", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_dyn_double_uint", - expr: "dyn(2.0) \u003e= 1u", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_int_uint", - expr: "dyn(0) \u003e= 1u", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_int_double", - expr: "dyn(0) \u003e= 1.0", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_uint_int", - expr: "dyn(0u) \u003e= 1", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_uint_double", - expr: "dyn(0u) \u003e= 1.0", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_double_int", - expr: "dyn(0.0) \u003e= 1", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_double_uint", - expr: "dyn(0.0) \u003e= 1u", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_int_big_uint", - expr: "dyn(1) \u003e= 9223372036854775808u", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_small_int_uint", - expr: "dyn(-1) \u003e= 0u", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "gte_dyn_int_big_lossy_double", - expr: "dyn(9223372036854775807) \u003e= 9223372036854775808.0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_int_big_double", - expr: "dyn(9223372036854775807) \u003e= 9223372036854777857.0", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_dyn_int_small_lossy_double_equal", - description: - "The conversion of the int to double is lossy and the numbers end up being equal", - expr: "dyn(-9223372036854775808) \u003e= -9223372036854775809.0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_dyn_int_small_lossy_double_greater", - expr: "dyn(-9223372036854775808) \u003e= -9223372036854777857.0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_dyn_uint_small_int", - expr: "dyn(1u) \u003e= -1", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_dyn_big_uint_int", - expr: "dyn(9223372036854775808u) \u003e= 1", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_dyn_uint_small_double", - expr: "dyn(9223372036854775807u) \u003e= -1.0", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "not_gte_dyn_uint_big_double", - expr: "dyn(18446744073709551615u) \u003e= 18446744073709553665.0", - value: { boolValue: false }, - }, - ast: "_\u003e=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.8446744073709556e+19~double\n)~bool^greater_equals_double", - type: "bool", - }, - { - original: { - name: "gte_dyn_big_double_uint", - expr: "dyn(18446744073709553665.0) \u003e= 18446744073709551615u", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_equals_uint64", - type: "bool", - }, - { - original: { - name: "gte_dyn_big_double_int", - expr: "dyn(9223372036854775808.0) \u003e= 9223372036854775807", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_equals_int64", - type: "bool", - }, - { - original: { - name: "gte_dyn_small_double_int", - expr: "dyn(-9223372036854775809.0) \u003e= -9223372036854775808", - value: { boolValue: true }, - }, - ast: "_\u003e=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003e=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_equals_int64", - type: "bool", - }, - ], - }, - { - name: "in_list_literal", - tests: [ - { - original: { - name: "elem_not_in_empty_list", - expr: "'empty' in []", - value: { boolValue: false }, - }, - ast: '@in(\n "empty"^#*expr.Constant_StringValue#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "empty"~string,\n []~list(string)\n)~bool^in_list', - type: "bool", - }, - { - original: { - name: "elem_in_list", - expr: "'elem' in ['elem', 'elemA', 'elemB']", - value: { boolValue: true }, - }, - ast: '@in(\n "elem"^#*expr.Constant_StringValue#,\n [\n "elem"^#*expr.Constant_StringValue#,\n "elemA"^#*expr.Constant_StringValue#,\n "elemB"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "elem"~string,\n [\n "elem"~string,\n "elemA"~string,\n "elemB"~string\n ]~list(string)\n)~bool^in_list', - type: "bool", - }, - { - original: { - name: "elem_not_in_list", - expr: "'not' in ['elem1', 'elem2', 'elem3']", - value: { boolValue: false }, - }, - ast: '@in(\n "not"^#*expr.Constant_StringValue#,\n [\n "elem1"^#*expr.Constant_StringValue#,\n "elem2"^#*expr.Constant_StringValue#,\n "elem3"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "not"~string,\n [\n "elem1"~string,\n "elem2"~string,\n "elem3"~string\n ]~list(string)\n)~bool^in_list', - type: "bool", - }, - { - original: { - name: "elem_in_mixed_type_list", - description: - "Set membership tests should succeed if the 'elem' exists in a mixed element type list.", - expr: "'elem' in [1, 'elem', 2]", - value: { boolValue: true }, - }, - ast: '@in(\n "elem"^#*expr.Constant_StringValue#,\n [\n 1^#*expr.Constant_Int64Value#,\n "elem"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "elem"~string,\n [\n 1~int,\n "elem"~string,\n 2~int\n ]~list(dyn)\n)~bool^in_list', - type: "bool", - }, - { - original: { - name: "elem_in_mixed_type_list_cross_type", - description: - "Set membership tests should return false due to the introduction of heterogeneous-equality. Set membership via 'in' is equivalent to the macro exists() behavior.", - expr: "'elem' in [1u, 'str', 2, b'bytes']", - value: { boolValue: false }, - }, - ast: '@in(\n "elem"^#*expr.Constant_StringValue#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n "str"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#,\n b"bytes"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "elem"~string,\n [\n 1u~uint,\n "str"~string,\n 2~int,\n b"bytes"~bytes\n ]~list(dyn)\n)~bool^in_list', - type: "bool", - }, - ], - }, - { - name: "in_map_literal", - tests: [ - { - original: { - name: "key_not_in_empty_map", - expr: "'empty' in {}", - value: { boolValue: false }, - }, - ast: '@in(\n "empty"^#*expr.Constant_StringValue#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "empty"~string,\n {}~map(string, dyn)\n)~bool^in_map', - type: "bool", - }, - { - original: { - name: "key_in_map", - expr: "'key' in {'key':'1', 'other':'2'}", - value: { boolValue: true }, - }, - ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n "key"^#*expr.Constant_StringValue#:"1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "other"^#*expr.Constant_StringValue#:"2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "key"~string,\n {\n "key"~string:"1"~string,\n "other"~string:"2"~string\n }~map(string, string)\n)~bool^in_map', - type: "bool", - }, - { - original: { - name: "key_not_in_map", - expr: "'key' in {'lock':1, 'gate':2}", - value: { boolValue: false }, - }, - ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n "lock"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "gate"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "key"~string,\n {\n "lock"~string:1~int,\n "gate"~string:2~int\n }~map(string, int)\n)~bool^in_map', - type: "bool", - }, - { - original: { - name: "key_in_mixed_key_type_map", - description: - "Map keys are of mixed type, but since the key is present the result is true.", - expr: "'key' in {3:3.0, 'key':2u}", - value: { boolValue: true }, - }, - ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n 3^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "key"^#*expr.Constant_StringValue#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "key"~string,\n {\n 3~int:3~double,\n "key"~string:2u~uint\n }~map(dyn, dyn)\n)~bool^in_map', - type: "bool", - }, - { - original: { - name: "key_in_mixed_key_type_map_cross_type", - expr: "'key' in {1u:'str', 2:b'bytes'}", - value: { boolValue: false }, - }, - ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n 1u^#*expr.Constant_Uint64Value#:"str"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:b"bytes"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "key"~string,\n {\n 1u~uint:"str"~string,\n 2~int:b"bytes"~bytes\n }~map(dyn, dyn)\n)~bool^in_map', - type: "bool", - }, - ], - }, - { - name: "bound", - tests: [ - { - original: { - name: "bytes_gt_left_false", - expr: "x \u003e b'\u0000'", - typeEnv: [ - { name: "x", ident: { type: { primitive: "BYTES" } } }, - ], - bindings: { x: { value: { bytesValue: "AA==" } } }, - value: { boolValue: false }, - }, - ast: '_\u003e_(\n x^#*expr.Expr_IdentExpr#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n x~bytes^x,\n b"\\x00"~bytes\n)~bool^greater_bytes', - type: "bool", - }, - { - original: { - name: "int_lte_right_true", - expr: "123 \u003c= x", - typeEnv: [ - { name: "x", ident: { type: { primitive: "INT64" } } }, - ], - bindings: { x: { value: { int64Value: "124" } } }, - value: { boolValue: true }, - }, - ast: "_\u003c=_(\n 123^#*expr.Constant_Int64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c=_(\n 123~int,\n x~int^x\n)~bool^less_equals_int64", - type: "bool", - }, - { - original: { - name: "bool_lt_right_true", - expr: "false \u003c x", - typeEnv: [ - { name: "x", ident: { type: { primitive: "BOOL" } } }, - ], - bindings: { x: { value: { boolValue: true } } }, - value: { boolValue: true }, - }, - ast: "_\u003c_(\n false^#*expr.Constant_BoolValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u003c_(\n false~bool,\n x~bool^x\n)~bool^less_bool", - type: "bool", - }, - { - original: { - name: "double_ne_left_false", - expr: "x != 9.8", - typeEnv: [ - { name: "x", ident: { type: { primitive: "DOUBLE" } } }, - ], - bindings: { x: { value: { doubleValue: 9.8 } } }, - value: { boolValue: false }, - }, - ast: "_!=_(\n x^#*expr.Expr_IdentExpr#,\n 9.8^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n x~double^x,\n 9.8~double\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "map_ne_right_false", - expr: "{'a':'b','c':'d'} != x", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "c" }, - value: { stringValue: "d" }, - }, - { - key: { stringValue: "a" }, - value: { stringValue: "b" }, - }, - ], - }, - }, - }, - }, - value: { boolValue: false }, - }, - ast: '_!=_(\n {\n "a"^#*expr.Constant_StringValue#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "c"^#*expr.Constant_StringValue#:"d"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n {\n "a"~string:"b"~string,\n "c"~string:"d"~string\n }~map(string, string),\n x~map(string, string)^x\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "null_eq_left_true", - description: - "A comparison _==_ against null only binds if the type is determined to be null or we skip the type checking", - expr: "x == null", - typeEnv: [{ name: "x", ident: { type: { null: null } } }], - bindings: { x: { value: { nullValue: null } } }, - value: { boolValue: true }, - }, - ast: "_==_(\n x^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n x~null^x,\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "list_eq_right_false", - expr: "[1, 2] == x", - typeEnv: [ - { - name: "x", - ident: { - type: { listType: { elemType: { primitive: "INT64" } } }, - }, - }, - ], - bindings: { - x: { - value: { - listValue: { - values: [{ int64Value: "2" }, { int64Value: "1" }], - }, - }, - }, - }, - value: { boolValue: false }, - }, - ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n [\n 1~int,\n 2~int\n ]~list(int),\n x~list(int)^x\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "string_gte_right_true", - expr: "'abcd' \u003e= x", - typeEnv: [ - { name: "x", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { x: { value: { stringValue: "abc" } } }, - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n "abcd"^#*expr.Constant_StringValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n "abcd"~string,\n x~string^x\n)~bool^greater_equals_string', - type: "bool", - }, - { - original: { - name: "uint_eq_right_false", - expr: "999u == x", - typeEnv: [ - { name: "x", ident: { type: { primitive: "UINT64" } } }, - ], - bindings: { x: { value: { uint64Value: "1000" } } }, - value: { boolValue: false }, - }, - ast: "_==_(\n 999u^#*expr.Constant_Uint64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_==_(\n 999u~uint,\n x~uint^x\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "null_lt_right_no_such_overload", - description: - "There is no _\u003c_ operation for null, even if both operands are null", - expr: "null \u003c x", - disableCheck: true, - bindings: { x: { value: { nullValue: null } } }, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "_\u003c_(\n null^#*expr.Constant_NullValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:8: undeclared reference to 'x' (in container '')\n | null \u003c x\n | .......^", - }, - ], - }, - ], - }, - { - name: "conversions", - suites: [ - { - name: "bytes", - tests: [ - { - original: { - name: "string_empty", - expr: "bytes('')", - value: { bytesValue: "" }, - }, - ast: 'bytes(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bytes(\n ""~string\n)~bytes^string_to_bytes', - type: "bytes", - }, - { - original: { - name: "string", - expr: "bytes('abc')", - value: { bytesValue: "YWJj" }, - }, - ast: 'bytes(\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bytes(\n "abc"~string\n)~bytes^string_to_bytes', - type: "bytes", - }, - { - original: { - name: "string_unicode", - expr: "bytes('ÿ')", - value: { bytesValue: "w78=" }, - }, - ast: 'bytes(\n "ÿ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bytes(\n "ÿ"~string\n)~bytes^string_to_bytes', - type: "bytes", - }, - { - original: { - name: "string_unicode_vs_literal", - expr: "bytes('\\377') == b'\\377'", - value: { boolValue: false }, - }, - ast: '_==_(\n bytes(\n "ÿ"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n b"\\xff"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n bytes(\n "ÿ"~string\n )~bytes^string_to_bytes,\n b"\\xff"~bytes\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "double", - tests: [ - { - original: { - name: "int_zero", - expr: "double(0)", - value: { doubleValue: 0 }, - }, - ast: "double(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "double(\n 0~int\n)~double^int64_to_double", - type: "double", - }, - { - original: { - name: "int_pos", - expr: "double(1000000000000)", - value: { doubleValue: 1000000000000 }, - }, - ast: "double(\n 1000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n 1000000000000~int\n)~double^int64_to_double", - type: "double", - }, - { - original: { - name: "int_neg", - expr: "double(-1000000000000000)", - value: { doubleValue: -1000000000000000 }, - }, - ast: "double(\n -1000000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n -1000000000000000~int\n)~double^int64_to_double", - type: "double", - }, - { - original: { - name: "int_min_exact", - description: "Smallest contiguous representable int (-2^53).", - expr: "double(-9007199254740992)", - value: { doubleValue: -9007199254740992 }, - }, - ast: "double(\n -9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n -9007199254740992~int\n)~double^int64_to_double", - type: "double", - }, - { - original: { - name: "int_max_exact", - description: "Largest contiguous representable int (2^53).", - expr: "double(9007199254740992)", - value: { doubleValue: 9007199254740992 }, - }, - ast: "double(\n 9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n 9007199254740992~int\n)~double^int64_to_double", - type: "double", - }, - { - original: { - name: "int_range", - description: "Largest signed 64-bit. Rounds to nearest double.", - expr: "double(9223372036854775807)", - value: { doubleValue: 9223372036854776000 }, - }, - ast: "double(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n 9223372036854775807~int\n)~double^int64_to_double", - type: "double", - }, - { - original: { - name: "uint_zero", - expr: "double(0u)", - value: { doubleValue: 0 }, - }, - ast: "double(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "double(\n 0u~uint\n)~double^uint64_to_double", - type: "double", - }, - { - original: { - name: "uint_pos", - expr: "double(123u)", - value: { doubleValue: 123 }, - }, - ast: "double(\n 123u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "double(\n 123u~uint\n)~double^uint64_to_double", - type: "double", - }, - { - original: { - name: "uint_max_exact", - description: "Largest contiguous representable int (2^53).", - expr: "double(9007199254740992u)", - value: { doubleValue: 9007199254740992 }, - }, - ast: "double(\n 9007199254740992u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n 9007199254740992u~uint\n)~double^uint64_to_double", - type: "double", - }, - { - original: { - name: "uint_range", - description: "Largest unsigned 64-bit.", - expr: "double(18446744073709551615u)", - value: { doubleValue: 18446744073709552000 }, - }, - ast: "double(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "double(\n 18446744073709551615u~uint\n)~double^uint64_to_double", - type: "double", - }, - { - original: { - name: "string_zero", - expr: "double('0')", - value: { doubleValue: 0 }, - }, - ast: 'double(\n "0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'double(\n "0"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_zero_dec", - expr: "double('0.0')", - value: { doubleValue: 0 }, - }, - ast: 'double(\n "0.0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'double(\n "0.0"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_neg_zero", - expr: "double('-0.0')", - value: { doubleValue: 0 }, - }, - ast: 'double(\n "-0.0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'double(\n "-0.0"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_no_dec", - expr: "double('123')", - value: { doubleValue: 123 }, - }, - ast: 'double(\n "123"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'double(\n "123"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_pos", - expr: "double('123.456')", - value: { doubleValue: 123.456 }, - }, - ast: 'double(\n "123.456"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'double(\n "123.456"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_neg", - expr: "double('-987.654')", - value: { doubleValue: -987.654 }, - }, - ast: 'double(\n "-987.654"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'double(\n "-987.654"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_exp_pos_pos", - expr: "double('6.02214e23')", - value: { doubleValue: 6.02214e23 }, - }, - ast: 'double(\n "6.02214e23"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'double(\n "6.02214e23"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_exp_pos_neg", - expr: "double('1.38e-23')", - value: { doubleValue: 1.38e-23 }, - }, - ast: 'double(\n "1.38e-23"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'double(\n "1.38e-23"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_exp_neg_pos", - expr: "double('-84.32e7')", - value: { doubleValue: -843200000 }, - }, - ast: 'double(\n "-84.32e7"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'double(\n "-84.32e7"~string\n)~double^string_to_double', - type: "double", - }, - { - original: { - name: "string_exp_neg_neg", - expr: "double('-5.43e-21')", - value: { doubleValue: -5.43e-21 }, - }, - ast: 'double(\n "-5.43e-21"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'double(\n "-5.43e-21"~string\n)~double^string_to_double', - type: "double", - }, - ], - }, - { - name: "dyn", - tests: [ - { - original: { - name: "dyn_heterogeneous_list", - description: "No need to disable type checking.", - expr: "type(dyn([1, 'one']))", - value: { typeValue: "list" }, - }, - ast: 'type(\n dyn(\n [\n 1^#*expr.Constant_Int64Value#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'type(\n dyn(\n [\n 1~int,\n "one"~string\n ]~list(dyn)\n )~dyn^to_dyn\n)~type(dyn)^type', - type: "type(dyn)", - }, - ], - }, - { - name: "int", - tests: [ - { - original: { - name: "uint", - expr: "int(42u)", - value: { int64Value: "42" }, - }, - ast: "int(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n 42u~uint\n)~int^uint64_to_int64", - type: "int", - }, - { - original: { - name: "uint_zero", - expr: "int(0u)", - value: { int64Value: "0" }, - }, - ast: "int(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n 0u~uint\n)~int^uint64_to_int64", - type: "int", - }, - { - original: { - name: "uint_max_exact", - expr: "int(9223372036854775807u)", - value: { int64Value: "9223372036854775807" }, - }, - ast: "int(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n 9223372036854775807u~uint\n)~int^uint64_to_int64", - type: "int", - }, - { - original: { - name: "uint_range", - expr: "int(18446744073709551615u)", - evalError: { errors: [{ message: "range error" }] }, - }, - ast: "int(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n 18446744073709551615u~uint\n)~int^uint64_to_int64", - type: "int", - }, - { - original: { - name: "double_round_neg", - expr: "int(-123.456)", - value: { int64Value: "-123" }, - }, - ast: "int(\n -123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n -123.456~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_truncate", - expr: "int(1.9)", - value: { int64Value: "1" }, - }, - ast: "int(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n 1.9~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_truncate_neg", - expr: "int(-7.9)", - value: { int64Value: "-7" }, - }, - ast: "int(\n -7.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n -7.9~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_half_pos", - expr: "int(11.5)", - value: { int64Value: "11" }, - }, - ast: "int(\n 11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n 11.5~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_half_neg", - expr: "int(-3.5)", - value: { int64Value: "-3" }, - }, - ast: "int(\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n -3.5~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_big_exact", - description: - "Beyond exact range (2^53), but no loss of precision (2^55).", - expr: "int(double(36028797018963968))", - value: { int64Value: "36028797018963968" }, - }, - ast: "int(\n double(\n 36028797018963968^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n double(\n 36028797018963968~int\n )~double^int64_to_double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_big_precision", - description: - "Beyond exact range (2^53), but loses precision (2^55 + 1).", - expr: "int(double(36028797018963969))", - value: { int64Value: "36028797018963968" }, - }, - ast: "int(\n double(\n 36028797018963969^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n double(\n 36028797018963969~int\n )~double^int64_to_double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_int_max_range", - description: - "The double(2^63-1) cast produces a floating point value outside the int range", - expr: "int(9223372036854775807.0)", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "int(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n 9.223372036854776e+18~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_int_min_range", - description: - "The double(-2^63) cast produces a floating point value outside the int range", - expr: "int(-9223372036854775808.0)", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "int(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n -9.223372036854776e+18~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_range", - expr: "int(1e99)", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "int(\n 1e+99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n 1e+99~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "string", - expr: "int('987')", - value: { int64Value: "987" }, - }, - ast: 'int(\n "987"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'int(\n "987"~string\n)~int^string_to_int64', - type: "int", - }, - { - original: { - name: "timestamp", - expr: "int(timestamp('2004-09-16T23:59:59Z'))", - value: { int64Value: "1095379199" }, - }, - ast: 'int(\n timestamp(\n "2004-09-16T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'int(\n timestamp(\n "2004-09-16T23:59:59Z"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64', - type: "int", - }, - ], - }, - { - name: "string", - tests: [ - { - original: { - name: "int", - expr: "string(123)", - value: { stringValue: "123" }, - }, - ast: "string(\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "string(\n 123~int\n)~string^int64_to_string", - type: "string", - }, - { - original: { - name: "int_neg", - expr: "string(-456)", - value: { stringValue: "-456" }, - }, - ast: "string(\n -456^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "string(\n -456~int\n)~string^int64_to_string", - type: "string", - }, - { - original: { - name: "uint", - expr: "string(9876u)", - value: { stringValue: "9876" }, - }, - ast: "string(\n 9876u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "string(\n 9876u~uint\n)~string^uint64_to_string", - type: "string", - }, - { - original: { - name: "double", - expr: "string(123.456)", - value: { stringValue: "123.456" }, - }, - ast: "string(\n 123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "string(\n 123.456~double\n)~string^double_to_string", - type: "string", - }, - { - original: { - name: "double_hard", - expr: "string(-4.5e-3)", - value: { stringValue: "-0.0045" }, - }, - ast: "string(\n -0.0045^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "string(\n -0.0045~double\n)~string^double_to_string", - type: "string", - }, - { - original: { - name: "bytes", - expr: "string(b'abc')", - value: { stringValue: "abc" }, - }, - ast: 'string(\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'string(\n b"abc"~bytes\n)~string^bytes_to_string', - type: "string", - }, - { - original: { - name: "bytes_unicode", - expr: "string(b'\\303\\277')", - value: { stringValue: "ÿ" }, - }, - ast: 'string(\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'string(\n b"ÿ"~bytes\n)~string^bytes_to_string', - type: "string", - }, - { - original: { - name: "bytes_invalid", - expr: "string(b'\\000\\xff')", - evalError: { errors: [{ message: "invalid UTF-8" }] }, - }, - ast: 'string(\n b"\\x00\\xff"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'string(\n b"\\x00\\xff"~bytes\n)~string^bytes_to_string', - type: "string", - }, - ], - }, - { - name: "type", - tests: [ - { - original: { - name: "bool", - expr: "type(true)", - value: { typeValue: "bool" }, - }, - ast: "type(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "type(\n true~bool\n)~type(bool)^type", - type: "type(bool)", - }, - { - original: { - name: "bool_denotation", - expr: "bool", - value: { typeValue: "bool" }, - }, - ast: "bool^#*expr.Expr_IdentExpr#", - checkedAst: "bool~type(bool)^bool", - type: "type(bool)", - }, - { - original: { - name: "dyn_no_denotation", - expr: "dyn", - disableCheck: true, - evalError: { errors: [{ message: "unknown variable" }] }, - }, - ast: "dyn^#*expr.Expr_IdentExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'dyn' (in container '')\n | dyn\n | ^", - }, - { - original: { - name: "int", - expr: "type(0)", - value: { typeValue: "int" }, - }, - ast: "type(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "type(\n 0~int\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "int_denotation", - expr: "int", - value: { typeValue: "int" }, - }, - ast: "int^#*expr.Expr_IdentExpr#", - checkedAst: "int~type(int)^int", - type: "type(int)", - }, - { - original: { - name: "eq_same", - expr: "type(true) == type(false)", - value: { boolValue: true }, - }, - ast: "_==_(\n type(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n type(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n type(\n true~bool\n )~type(bool)^type,\n type(\n false~bool\n )~type(bool)^type\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "uint", - expr: "type(64u)", - value: { typeValue: "uint" }, - }, - ast: "type(\n 64u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "type(\n 64u~uint\n)~type(uint)^type", - type: "type(uint)", - }, - { - original: { - name: "uint_denotation", - expr: "uint", - value: { typeValue: "uint" }, - }, - ast: "uint^#*expr.Expr_IdentExpr#", - checkedAst: "uint~type(uint)^uint", - type: "type(uint)", - }, - { - original: { - name: "double", - expr: "type(3.14)", - value: { typeValue: "double" }, - }, - ast: "type(\n 3.14^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "type(\n 3.14~double\n)~type(double)^type", - type: "type(double)", - }, - { - original: { - name: "double_denotation", - expr: "double", - value: { typeValue: "double" }, - }, - ast: "double^#*expr.Expr_IdentExpr#", - checkedAst: "double~type(double)^double", - type: "type(double)", - }, - { - original: { - name: "null_type", - expr: "type(null)", - value: { typeValue: "null_type" }, - }, - ast: "type(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "type(\n null~null\n)~type(null)^type", - type: "type(null)", - }, - { - original: { - name: "null_type_denotation", - expr: "null_type", - value: { typeValue: "null_type" }, - }, - ast: "null_type^#*expr.Expr_IdentExpr#", - checkedAst: "null_type~type(null)^null_type", - type: "type(null)", - }, - { - original: { - name: "string", - expr: "type('foo')", - value: { typeValue: "string" }, - }, - ast: 'type(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'type(\n "foo"~string\n)~type(string)^type', - type: "type(string)", - }, - { - original: { - name: "string_denotation", - expr: "string", - value: { typeValue: "string" }, - }, - ast: "string^#*expr.Expr_IdentExpr#", - checkedAst: "string~type(string)^string", - type: "type(string)", - }, - { - original: { - name: "bytes", - expr: "type(b'\\xff')", - value: { typeValue: "bytes" }, - }, - ast: 'type(\n b"\\xff"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'type(\n b"\\xff"~bytes\n)~type(bytes)^type', - type: "type(bytes)", - }, - { - original: { - name: "bytes_denotation", - expr: "bytes", - value: { typeValue: "bytes" }, - }, - ast: "bytes^#*expr.Expr_IdentExpr#", - checkedAst: "bytes~type(bytes)^bytes", - type: "type(bytes)", - }, - { - original: { - name: "list", - expr: "type([1, 2, 3])", - value: { typeValue: "list" }, - }, - ast: "type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~type(list(int))^type", - type: "type(list(int))", - }, - { - original: { - name: "list_denotation", - expr: "list", - value: { typeValue: "list" }, - }, - ast: "list^#*expr.Expr_IdentExpr#", - checkedAst: "list~type(list(dyn))^list", - type: "type(list(dyn))", - }, - { - original: { - name: "lists_monomorphic", - expr: "type([1, 2, 3]) == type(['one', 'two', 'three'])", - value: { boolValue: true }, - }, - ast: '_==_(\n type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n [\n "one"^#*expr.Constant_StringValue#,\n "two"^#*expr.Constant_StringValue#,\n "three"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n )~type(list(int))^type,\n type(\n [\n "one"~string,\n "two"~string,\n "three"~string\n ]~list(string)\n )~type(list(string))^type\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "map", - expr: "type({4: 16})", - value: { typeValue: "map" }, - }, - ast: "type(\n {\n 4^#*expr.Constant_Int64Value#:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n {\n 4~int:16~int\n }~map(int, int)\n)~type(map(int, int))^type", - type: "type(map(int, int))", - }, - { - original: { - name: "map_denotation", - expr: "map", - value: { typeValue: "map" }, - }, - ast: "map^#*expr.Expr_IdentExpr#", - checkedAst: "map~type(map(dyn, dyn))^map", - type: "type(map(dyn, dyn))", - }, - { - original: { - name: "map_monomorphic", - expr: "type({'one': 1}) == type({1: 'one'})", - value: { boolValue: true }, - }, - ast: '_==_(\n type(\n {\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n {\n 1^#*expr.Constant_Int64Value#:"one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n type(\n {\n "one"~string:1~int\n }~map(string, int)\n )~type(map(string, int))^type,\n type(\n {\n 1~int:"one"~string\n }~map(int, string)\n )~type(map(int, string))^type\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_diff", - expr: "type(7) == type(7u)", - value: { boolValue: false }, - }, - ast: "_==_(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n type(\n 7~int\n )~type(int)^type,\n type(\n 7u~uint\n )~type(uint)^type\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "neq_same", - expr: "type(0.0) != type(-0.0)", - value: { boolValue: false }, - }, - ast: "_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n -0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n -0~double\n )~type(double)^type\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "neq_diff", - expr: "type(0.0) != type(0)", - value: { boolValue: true }, - }, - ast: "_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n 0~int\n )~type(int)^type\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "meta", - expr: "type(type(7)) == type(type(7u))", - value: { boolValue: true }, - }, - ast: "_==_(\n type(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n type(\n type(\n 7~int\n )~type(int)^type\n )~type(type(int))^type,\n type(\n type(\n 7u~uint\n )~type(uint)^type\n )~type(type(uint))^type\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "type", - expr: "type(int)", - value: { typeValue: "type" }, - }, - ast: "type(\n int^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: "type(\n int~type(int)^int\n)~type(type(int))^type", - type: "type(type(int))", - }, - { - original: { - name: "type_denotation", - expr: "type", - value: { typeValue: "type" }, - }, - ast: "type^#*expr.Expr_IdentExpr#", - checkedAst: "type~type(type)^type", - type: "type(type)", - }, - { - original: { - name: "type_type", - expr: "type(type)", - value: { typeValue: "type" }, - }, - ast: "type(\n type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n type~type(type)^type\n)~type(type(type))^type", - type: "type(type(type))", - }, - ], - }, - { - name: "uint", - tests: [ - { - original: { - name: "int", - expr: "uint(1729)", - value: { uint64Value: "1729" }, - }, - ast: "uint(\n 1729^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n 1729~int\n)~uint^int64_to_uint64", - type: "uint", - }, - { - original: { - name: "int_max", - expr: "uint(9223372036854775807)", - value: { uint64Value: "9223372036854775807" }, - }, - ast: "uint(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "uint(\n 9223372036854775807~int\n)~uint^int64_to_uint64", - type: "uint", - }, - { - original: { - name: "int_neg", - expr: "uint(-1)", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "uint(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n -1~int\n)~uint^int64_to_uint64", - type: "uint", - }, - { - original: { - name: "double", - expr: "uint(3.14159265)", - value: { uint64Value: "3" }, - }, - ast: "uint(\n 3.14159265^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n 3.14159265~double\n)~uint^double_to_uint64", - type: "uint", - }, - { - original: { - name: "double_truncate", - expr: "uint(1.9)", - value: { uint64Value: "1" }, - }, - ast: "uint(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n 1.9~double\n)~uint^double_to_uint64", - type: "uint", - }, - { - original: { - name: "double_half", - expr: "uint(25.5)", - value: { uint64Value: "25" }, - }, - ast: "uint(\n 25.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n 25.5~double\n)~uint^double_to_uint64", - type: "uint", - }, - { - original: { - name: "double_big_exact", - description: - "Beyond exact range (2^53), but no loss of precision (2^55).", - expr: "uint(double(36028797018963968u))", - value: { uint64Value: "36028797018963968" }, - }, - ast: "uint(\n double(\n 36028797018963968u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "uint(\n double(\n 36028797018963968u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64", - type: "uint", - }, - { - original: { - name: "double_big_precision", - description: - "Beyond exact range (2^53), but loses precision (2^55 + 1).", - expr: "uint(double(36028797018963969u))", - value: { uint64Value: "36028797018963968" }, - }, - ast: "uint(\n double(\n 36028797018963969u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "uint(\n double(\n 36028797018963969u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64", - type: "uint", - }, - { - original: { - name: "double_uint_max_range", - description: - "The exact conversion of uint max as a double does not round trip.", - expr: "int(18446744073709551615.0)", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "int(\n 1.8446744073709552e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n 1.8446744073709552e+19~double\n)~int^double_to_int64", - type: "int", - }, - { - original: { - name: "double_range_beyond_uint", - expr: "uint(6.022e23)", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "uint(\n 6.022e+23^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n 6.022e+23~double\n)~uint^double_to_uint64", - type: "uint", - }, - { - original: { - name: "string", - expr: "uint('300')", - value: { uint64Value: "300" }, - }, - ast: 'uint(\n "300"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'uint(\n "300"~string\n)~uint^string_to_uint64', - type: "uint", - }, - ], - }, - { - name: "bool", - tests: [ - { - original: { - name: "string_1", - expr: "bool('1')", - value: { boolValue: true }, - }, - ast: 'bool(\n "1"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "1"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_t", - expr: "bool('t')", - value: { boolValue: true }, - }, - ast: 'bool(\n "t"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "t"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_true_lowercase", - expr: "bool('true')", - value: { boolValue: true }, - }, - ast: 'bool(\n "true"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "true"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_true_uppercase", - expr: "bool('TRUE')", - value: { boolValue: true }, - }, - ast: 'bool(\n "TRUE"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "TRUE"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_true_pascalcase", - expr: "bool('True')", - value: { boolValue: true }, - }, - ast: 'bool(\n "True"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "True"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_0", - expr: "bool('0')", - value: { boolValue: false }, - }, - ast: 'bool(\n "0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "0"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_f", - expr: "bool('f')", - value: { boolValue: false }, - }, - ast: 'bool(\n "f"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "f"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_false_lowercase", - expr: "bool('false')", - value: { boolValue: false }, - }, - ast: 'bool(\n "false"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "false"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_false_uppercase", - expr: "bool('FALSE')", - value: { boolValue: false }, - }, - ast: 'bool(\n "FALSE"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "FALSE"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_false_pascalcase", - expr: "bool('False')", - value: { boolValue: false }, - }, - ast: 'bool(\n "False"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "False"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_true_badcase", - expr: "bool('TrUe')", - evalError: { errors: [{ message: "Type conversion error" }] }, - }, - ast: 'bool(\n "TrUe"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "TrUe"~string\n)~bool^string_to_bool', - type: "bool", - }, - { - original: { - name: "string_false_badcase", - expr: "bool('FaLsE')", - evalError: { errors: [{ message: "Type conversion error" }] }, - }, - ast: 'bool(\n "FaLsE"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bool(\n "FaLsE"~string\n)~bool^string_to_bool', - type: "bool", - }, - ], - }, - { - name: "identity", - tests: [ - { - original: { - name: "bool", - expr: "bool(true)", - value: { boolValue: true }, - }, - ast: "bool(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "bool(\n true~bool\n)~bool^bool_to_bool", - type: "bool", - }, - { - original: { - name: "int", - expr: "int(1)", - value: { int64Value: "1" }, - }, - ast: "int(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "int(\n 1~int\n)~int^int64_to_int64", - type: "int", - }, - { - original: { - name: "uint", - expr: "uint(1u)", - value: { uint64Value: "1" }, - }, - ast: "uint(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "uint(\n 1u~uint\n)~uint^uint64_to_uint64", - type: "uint", - }, - { - original: { - name: "double", - expr: "double(5.5)", - value: { doubleValue: 5.5 }, - }, - ast: "double(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "double(\n 5.5~double\n)~double^double_to_double", - type: "double", - }, - { - original: { - name: "string", - expr: "string('hello')", - value: { stringValue: "hello" }, - }, - ast: 'string(\n "hello"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'string(\n "hello"~string\n)~string^string_to_string', - type: "string", - }, - { - original: { - name: "bytes", - expr: "bytes(b'abc')", - value: { bytesValue: "YWJj" }, - }, - ast: 'bytes(\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'bytes(\n b"abc"~bytes\n)~bytes^bytes_to_bytes', - type: "bytes", - }, - { - original: { - name: "duration", - expr: "duration(duration('100s')) == duration('100s')", - value: { boolValue: true }, - }, - ast: '_==_(\n duration(\n duration(\n "100s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "100s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n duration(\n duration(\n "100s"~string\n )~duration^string_to_duration\n )~duration^duration_to_duration,\n duration(\n "100s"~string\n )~duration^string_to_duration\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "timestamp", - expr: "timestamp(timestamp(1000000000)) == timestamp(1000000000)", - value: { boolValue: true }, - }, - ast: "_==_(\n timestamp(\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n timestamp(\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n )~timestamp^timestamp_to_timestamp,\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n)~bool^equals", - type: "bool", - }, - ], - }, - ], - }, - { - name: "dynamic", - suites: [ - { - name: "int32", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Int32Value{value: -123}", - value: { int64Value: "-123" }, - }, - ast: "google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Int32Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int32Value", - type: "wrapper(int)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Int32Value{value: -123}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int32Value{value: -123}.value\n | .......................................^", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.Int32Value{}", - value: { int64Value: "0" }, - }, - ast: "google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value", - type: "wrapper(int)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.Int32Value" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.Int32Value", - value: 2000000, - }, - }, - }, - }, - value: { int64Value: "2000000" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(int)^x", - type: "wrapper(int)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_int32_wrapper: 432}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32Wrapper: 432, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_int32_wrapper: 0}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32Wrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_max", - expr: "TestAllTypes{single_int32_wrapper: 2147483647}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32Wrapper: 2147483647, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_min", - expr: "TestAllTypes{single_int32_wrapper: -2147483648}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32Wrapper: -2147483648, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_range", - expr: "TestAllTypes{single_int32_wrapper: 12345678900}", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "range error" }] }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:12345678900^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:12345678900~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper", - container: "cel.expr.conformance.proto2", - value: { int64Value: "642" }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper", - container: "cel.expr.conformance.proto2", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "field_read_proto2_unset", - expr: "TestAllTypes{}.single_int32_wrapper", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_int32_wrapper: -975}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32Wrapper: -975, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_int32_wrapper: 0}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32Wrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_max", - expr: "TestAllTypes{single_int32_wrapper: 2147483647}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32Wrapper: 2147483647, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_min", - expr: "TestAllTypes{single_int32_wrapper: -2147483648}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32Wrapper: -2147483648, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_range", - expr: "TestAllTypes{single_int32_wrapper: -998877665544332211}", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "range error" }] }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:-998877665544332211^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-998877665544332211~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper", - container: "cel.expr.conformance.proto3", - value: { int64Value: "642" }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "field_read_proto3_zero", - expr: "TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper", - container: "cel.expr.conformance.proto3", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "field_read_proto3_unset", - expr: "TestAllTypes{}.single_int32_wrapper", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - ], - }, - { - name: "int64", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Int64Value{value: -123}", - value: { int64Value: "-123" }, - }, - ast: "google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Int64Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int64Value", - type: "wrapper(int)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Int64Value{value: -123}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int64Value{value: -123}.value\n | .......................................^", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.Int64Value{}", - value: { int64Value: "0" }, - }, - ast: "google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value", - type: "wrapper(int)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.Int64Value" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.Int64Value", - value: "2000000", - }, - }, - }, - }, - value: { int64Value: "2000000" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(int)^x", - type: "wrapper(int)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_int64_wrapper: 432}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt64Wrapper: "432", - }, - }, - }, - ast: "TestAllTypes{\n single_int64_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_int64_wrapper: 0}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt64Wrapper: "0", - }, - }, - }, - ast: "TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_int64_wrapper: -975}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64Wrapper: "-975", - }, - }, - }, - ast: "TestAllTypes{\n single_int64_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_int64_wrapper: 0}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64Wrapper: "0", - }, - }, - }, - ast: "TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "uint32", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.UInt32Value{value: 123u}", - value: { uint64Value: "123" }, - }, - ast: "google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.UInt32Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt32Value", - type: "wrapper(uint)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.UInt32Value{value: 123u}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt32Value{value: 123u}.value\n | ........................................^", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.UInt32Value{}", - value: { uint64Value: "0" }, - }, - ast: "google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value", - type: "wrapper(uint)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.UInt32Value" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.UInt32Value", - value: 2000000, - }, - }, - }, - }, - value: { uint64Value: "2000000" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(uint)^x", - type: "wrapper(uint)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_uint32_wrapper: 432u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint32Wrapper: 432, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_uint32_wrapper: 0u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint32Wrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_max", - expr: "TestAllTypes{single_uint32_wrapper: 4294967295u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint32Wrapper: 4294967295, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_range", - expr: "TestAllTypes{single_uint32_wrapper: 6111222333u}", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "range error" }] }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_uint32_wrapper: 975u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint32Wrapper: 975, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_uint32_wrapper: 0u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint32Wrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_max", - expr: "TestAllTypes{single_uint32_wrapper: 4294967295u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint32Wrapper: 4294967295, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_range", - expr: "TestAllTypes{single_uint32_wrapper: 6111222333u}", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "range error" }] }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_uint32_wrapper: 258u}.single_uint32_wrapper", - container: "cel.expr.conformance.proto2", - value: { uint64Value: "258" }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:258u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:258u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)", - type: "wrapper(uint)", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_uint32_wrapper: 0u}.single_uint32_wrapper", - container: "cel.expr.conformance.proto2", - value: { uint64Value: "0" }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)", - type: "wrapper(uint)", - }, - { - original: { - name: "field_read_proto2_unset", - expr: "TestAllTypes{}.single_uint32_wrapper", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)", - type: "wrapper(uint)", - }, - ], - }, - { - name: "uint64", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.UInt64Value{value: 123u}", - value: { uint64Value: "123" }, - }, - ast: "google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.UInt64Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt64Value", - type: "wrapper(uint)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.UInt64Value{value: 123u}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt64Value{value: 123u}.value\n | ........................................^", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.UInt64Value{}", - value: { uint64Value: "0" }, - }, - ast: "google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value", - type: "wrapper(uint)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.UInt64Value" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.UInt64Value", - value: "2000000", - }, - }, - }, - }, - value: { uint64Value: "2000000" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(uint)^x", - type: "wrapper(uint)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_uint64_wrapper: 432u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint64Wrapper: "432", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_uint64_wrapper: 0u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint64Wrapper: "0", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_uint64_wrapper: 975u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint64Wrapper: "975", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_uint64_wrapper: 0u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint64Wrapper: "0", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_uint64_wrapper: 5123123123u}.single_uint64_wrapper", - container: "cel.expr.conformance.proto2", - value: { uint64Value: "5123123123" }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:5123123123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:5123123123u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)", - type: "wrapper(uint)", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_uint64_wrapper: 0u}.single_uint64_wrapper", - container: "cel.expr.conformance.proto2", - value: { uint64Value: "0" }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)", - type: "wrapper(uint)", - }, - { - original: { - name: "field_read_proto2_unset", - expr: "TestAllTypes{}.single_uint64_wrapper", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)", - type: "wrapper(uint)", - }, - ], - }, - { - name: "float", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.FloatValue{value: -1.5e3}", - value: { doubleValue: -1500 }, - }, - ast: "google.protobuf.FloatValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.FloatValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.FloatValue", - type: "wrapper(double)", - }, - { - original: { - name: "literal_not_double", - description: - "Use a number with no exact representation to make sure we actually narrow to a float.", - expr: "google.protobuf.FloatValue{value: 1.333} == 1.333", - value: { boolValue: false }, - }, - ast: "_==_(\n google.protobuf.FloatValue{\n value:1.333^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1.333^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{\n value:1.333~double\n }~wrapper(double)^google.protobuf.FloatValue,\n 1.333~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.FloatValue{value: 3.1416}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.FloatValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:42: type 'wrapper(double)' does not support field selection\n | google.protobuf.FloatValue{value: 3.1416}.value\n | .........................................^", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.FloatValue{}", - value: { doubleValue: 0 }, - }, - ast: "google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue", - type: "wrapper(double)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.FloatValue" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.FloatValue", - value: -1250000, - }, - }, - }, - }, - value: { doubleValue: -1250000 }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(double)^x", - type: "wrapper(double)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_float_wrapper: 86.75}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: 86.75, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_float_wrapper: 0.0}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_subnorm", - description: - "Subnormal single floats range from ~1e-38 to ~1e-45.", - expr: "TestAllTypes{single_float_wrapper: 1e-40}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: 1e-40, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_round_to_zero", - description: - "Subnormal single floats range from ~1e-38 to ~1e-45.", - expr: "TestAllTypes{single_float_wrapper: 1e-50}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:1e-50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-50~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_range", - description: "Single float max is about 3.4e38", - expr: "TestAllTypes{single_float_wrapper: 1.4e55}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: "Infinity", - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_float_wrapper: -12.375}.single_float_wrapper", - container: "cel.expr.conformance.proto2", - value: { doubleValue: -12.375 }, - }, - ast: "TestAllTypes{\n single_float_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper", - container: "cel.expr.conformance.proto2", - value: { doubleValue: 0 }, - }, - ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto2_unset", - expr: "TestAllTypes{}.single_float_wrapper", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_float_wrapper: -9.75}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFloatWrapper: -9.75, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_float_wrapper: 0.0}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFloatWrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_subnorm", - description: - "Subnormal single floats range from ~1e-38 to ~1e-45.", - expr: "TestAllTypes{single_float_wrapper: 1e-40}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: 1e-40, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_round_to_zero", - expr: "TestAllTypes{single_float_wrapper: -9.9e-100}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFloatWrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:-9.9e-100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e-100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_range", - description: "Single float min is about -3.4e38", - expr: "TestAllTypes{single_float_wrapper: -9.9e100}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFloatWrapper: "-Infinity", - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_float_wrapper: 64.25}.single_float_wrapper", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 64.25 }, - }, - ast: "TestAllTypes{\n single_float_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto3_zero", - expr: "TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 0 }, - }, - ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto3_unset", - expr: "TestAllTypes{}.single_float_wrapper", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - ], - }, - { - name: "double", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.DoubleValue{value: -1.5e3}", - value: { doubleValue: -1500 }, - }, - ast: "google.protobuf.DoubleValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.DoubleValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.DoubleValue", - type: "wrapper(double)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.DoubleValue{value: 3.1416}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.DoubleValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:43: type 'wrapper(double)' does not support field selection\n | google.protobuf.DoubleValue{value: 3.1416}.value\n | ..........................................^", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.DoubleValue{}", - value: { doubleValue: 0 }, - }, - ast: "google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue", - type: "wrapper(double)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.DoubleValue" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.DoubleValue", - value: -1250000, - }, - }, - }, - }, - value: { doubleValue: -1250000 }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(double)^x", - type: "wrapper(double)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_double_wrapper: 86.75}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleDoubleWrapper: 86.75, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_double_wrapper: 0.0}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleDoubleWrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_range", - expr: "TestAllTypes{single_double_wrapper: 1.4e55}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleDoubleWrapper: 1.4e55, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_double_wrapper: -12.375}.single_double_wrapper", - container: "cel.expr.conformance.proto2", - value: { doubleValue: -12.375 }, - }, - ast: "TestAllTypes{\n single_double_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper", - container: "cel.expr.conformance.proto2", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "field_read_proto2_unset", - expr: "TestAllTypes{}.single_double_wrapper", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_double_wrapper: -9.75}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleDoubleWrapper: -9.75, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_double_wrapper: 0.0}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleDoubleWrapper: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_range", - expr: "TestAllTypes{single_double_wrapper: -9.9e100}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleDoubleWrapper: -9.9e100, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_double_wrapper: 64.25}.single_double_wrapper", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 64.25 }, - }, - ast: "TestAllTypes{\n single_double_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto3_zero", - expr: "TestAllTypes{single_double_wrapper: 0.0}.single_double_wrapper", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 0 }, - }, - ast: "TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - { - original: { - name: "field_read_proto3_unset", - expr: "TestAllTypes{}.single_double_wrapper", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)", - type: "wrapper(double)", - }, - ], - }, - { - name: "bool", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.BoolValue{value: true}", - value: { boolValue: true }, - }, - ast: "google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.BoolValue{\n value:true~bool\n}~wrapper(bool)^google.protobuf.BoolValue", - type: "wrapper(bool)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.BoolValue{value: true}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:39: type 'wrapper(bool)' does not support field selection\n | google.protobuf.BoolValue{value: true}.value\n | ......................................^", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.BoolValue{}", - value: { boolValue: false }, - }, - ast: "google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue", - type: "wrapper(bool)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.BoolValue" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.BoolValue", - value: true, - }, - }, - }, - }, - value: { boolValue: true }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(bool)^x", - type: "wrapper(bool)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_bool_wrapper: true}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBoolWrapper: true, - }, - }, - }, - ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_false", - expr: "TestAllTypes{single_bool_wrapper: false}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBoolWrapper: false, - }, - }, - }, - ast: "TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_bool_wrapper: true}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBoolWrapper: true, - }, - }, - }, - ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_false", - expr: "TestAllTypes{single_bool_wrapper: false}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBoolWrapper: false, - }, - }, - }, - ast: "TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "string", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.StringValue{value: 'foo'}", - value: { stringValue: "foo" }, - }, - ast: 'google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.StringValue{\n value:"foo"~string\n}~wrapper(string)^google.protobuf.StringValue', - type: "wrapper(string)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.StringValue{value: 'foo'}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#', - error: - "ERROR: \u003cinput\u003e:1:42: type 'wrapper(string)' does not support field selection\n | google.protobuf.StringValue{value: 'foo'}.value\n | .........................................^", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.StringValue{}", - value: { stringValue: "" }, - }, - ast: "google.protobuf.StringValue{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue", - type: "wrapper(string)", - }, - { - original: { - name: "literal_unicode", - expr: "google.protobuf.StringValue{value: 'flambé'}", - value: { stringValue: "flambé" }, - }, - ast: 'google.protobuf.StringValue{\n value:"flambé"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.StringValue{\n value:"flambé"~string\n}~wrapper(string)^google.protobuf.StringValue', - type: "wrapper(string)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.StringValue" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.StringValue", - value: "bar", - }, - }, - }, - }, - value: { stringValue: "bar" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(string)^x", - type: "wrapper(string)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_string_wrapper: 'baz'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleStringWrapper: "baz", - }, - }, - }, - ast: 'TestAllTypes{\n single_string_wrapper:"baz"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:"baz"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{single_string_wrapper: ''}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleStringWrapper: "", - }, - }, - }, - ast: 'TestAllTypes{\n single_string_wrapper:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:""~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_string_wrapper: 'bletch'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleStringWrapper: "bletch", - }, - }, - }, - ast: 'TestAllTypes{\n single_string_wrapper:"bletch"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:"bletch"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{single_string_wrapper: ''}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleStringWrapper: "", - }, - }, - }, - ast: 'TestAllTypes{\n single_string_wrapper:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:""~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "bytes", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.BytesValue{value: b'foo\\123'}", - value: { bytesValue: "Zm9vUw==" }, - }, - ast: 'google.protobuf.BytesValue{\n value:b"fooS"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.BytesValue{\n value:b"fooS"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue', - type: "wrapper(bytes)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.BytesValue{value: b'foo'}.value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.BytesValue{\n value:b"foo"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#', - error: - "ERROR: \u003cinput\u003e:1:42: type 'wrapper(bytes)' does not support field selection\n | google.protobuf.BytesValue{value: b'foo'}.value\n | .........................................^", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.BytesValue{}", - value: { bytesValue: "" }, - }, - ast: "google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue", - type: "wrapper(bytes)", - }, - { - original: { - name: "literal_unicode", - expr: "google.protobuf.BytesValue{value: b'flambé'}", - value: { bytesValue: "ZmxhbWLDqQ==" }, - }, - ast: 'google.protobuf.BytesValue{\n value:b"flambé"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.BytesValue{\n value:b"flambé"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue', - type: "wrapper(bytes)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.BytesValue" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.BytesValue", - value: "YmFy", - }, - }, - }, - }, - value: { bytesValue: "YmFy" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~wrapper(bytes)^x", - type: "wrapper(bytes)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_bytes_wrapper: b'baz'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBytesWrapper: "YmF6", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes_wrapper:b"baz"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b"baz"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{single_bytes_wrapper: b''}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBytesWrapper: "", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes_wrapper:b""^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b""~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_bytes_wrapper: b'bletch'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBytesWrapper: "YmxldGNo", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes_wrapper:b"bletch"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b"bletch"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{single_bytes_wrapper: b''}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBytesWrapper: "", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes_wrapper:b""^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b""~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "list", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.ListValue{values: [3.0, 'foo', null]}", - value: { - listValue: { - values: [ - { doubleValue: 3 }, - { stringValue: "foo" }, - { nullValue: null }, - ], - }, - }, - }, - ast: 'google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n "foo"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.ListValue{\n values:[\n 3~double,\n "foo"~string,\n null~null\n ]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue', - type: "list(dyn)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.ListValue{values: [3.0, 'foo', null]}.values", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n "foo"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.values^#*expr.Expr_SelectExpr#', - error: - "ERROR: \u003cinput\u003e:1:54: type 'list(dyn)' does not support field selection\n | google.protobuf.ListValue{values: [3.0, 'foo', null]}.values\n | .....................................................^", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.ListValue{values: []}", - value: { listValue: {} }, - }, - ast: "google.protobuf.ListValue{\n values:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.ListValue{\n values:[]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue", - type: "list(dyn)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.ListValue" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/google.protobuf.ListValue", - value: ["bar", ["a", "b"]], - }, - }, - }, - }, - value: { - listValue: { - values: [ - { stringValue: "bar" }, - { - listValue: { - values: [{ stringValue: "a" }, { stringValue: "b" }], - }, - }, - ], - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~list(dyn)^x", - type: "list(dyn)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{list_value: [1.0, 'one']}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - listValue: [1, "one"], - }, - }, - }, - ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{list_value: []}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - listValue: [], - }, - }, - }, - ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{list_value: [1.0, 'one']}.list_value", - container: "cel.expr.conformance.proto2", - value: { - listValue: { - values: [{ doubleValue: 1 }, { stringValue: "one" }], - }, - }, - }, - ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)', - type: "list(dyn)", - }, - { - original: { - name: "field_read_proto2_empty", - expr: "TestAllTypes{list_value: []}.list_value", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "field_read_proto2_unset", - description: "Not a wrapper type, so doesn't convert to null.", - expr: "TestAllTypes{}.list_value", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{list_value: [1.0, 'one']}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - listValue: [1, "one"], - }, - }, - }, - ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{list_value: []}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - listValue: [], - }, - }, - }, - ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{list_value: [1.0, 'one']}.list_value", - container: "cel.expr.conformance.proto3", - value: { - listValue: { - values: [{ doubleValue: 1 }, { stringValue: "one" }], - }, - }, - }, - ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)', - type: "list(dyn)", - }, - { - original: { - name: "field_read_proto3_empty", - expr: "TestAllTypes{list_value: []}.list_value", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "field_read_proto3_unset", - description: "Not a wrapper type, so doesn't convert to null.", - expr: "TestAllTypes{}.list_value", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)", - type: "list(dyn)", - }, - ], - }, - { - name: "struct", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "uno" }, - value: { doubleValue: 1 }, - }, - { - key: { stringValue: "dos" }, - value: { doubleValue: 2 }, - }, - ], - }, - }, - }, - ast: 'google.protobuf.Struct{\n fields:{\n "uno"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "dos"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.Struct{\n fields:{\n "uno"~string:1~double,\n "dos"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct', - type: "map(string, dyn)", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}.fields", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.Struct{\n fields:{\n "uno"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "dos"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.fields^#*expr.Expr_SelectExpr#', - checkedAst: - 'google.protobuf.Struct{\n fields:{\n "uno"~string:1~double,\n "dos"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct.fields~dyn', - type: "dyn", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.Struct{fields: {}}", - value: { mapValue: {} }, - }, - ast: "google.protobuf.Struct{\n fields:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Struct{\n fields:{}~map(string, dyn)\n}~map(string, dyn)^google.protobuf.Struct", - type: "map(string, dyn)", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Struct" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Struct", - value: { first: "Abraham", last: "Lincoln" }, - }, - }, - }, - }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "first" }, - value: { stringValue: "Abraham" }, - }, - { - key: { stringValue: "last" }, - value: { stringValue: "Lincoln" }, - }, - ], - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~map(string, dyn)^x", - type: "map(string, dyn)", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleStruct: { deux: 2, un: 1 }, - }, - }, - }, - ast: 'TestAllTypes{\n single_struct:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{single_struct: {}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleStruct: {}, - }, - }, - }, - ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_bad", - expr: "TestAllTypes{single_struct: {1: 'uno'}}", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "bad key type" }] }, - }, - ast: 'TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - error: - "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_struct: {'one': 1.0}}.single_struct", - container: "cel.expr.conformance.proto2", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "one" }, - value: { doubleValue: 1 }, - }, - ], - }, - }, - }, - ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n "one"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)', - type: "map(string, dyn)", - }, - { - original: { - name: "field_read_proto2_empty", - expr: "TestAllTypes{single_struct: {}}.single_struct", - container: "cel.expr.conformance.proto2", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)", - type: "map(string, dyn)", - }, - { - original: { - name: "field_read_proto2_unset", - description: "Not a wrapper type, so doesn't convert to null.", - expr: "TestAllTypes{}.single_struct", - container: "cel.expr.conformance.proto2", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)", - type: "map(string, dyn)", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleStruct: { deux: 2, un: 1 }, - }, - }, - }, - ast: 'TestAllTypes{\n single_struct:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{single_struct: {}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleStruct: {}, - }, - }, - }, - ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_bad", - expr: "TestAllTypes{single_struct: {1: 'uno'}}", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "bad key type" }] }, - }, - ast: 'TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - error: - "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_struct: {'one': 1.0}}.single_struct", - container: "cel.expr.conformance.proto3", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "one" }, - value: { doubleValue: 1 }, - }, - ], - }, - }, - }, - ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n "one"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)', - type: "map(string, dyn)", - }, - { - original: { - name: "field_read_proto3_empty", - expr: "TestAllTypes{single_struct: {}}.single_struct", - container: "cel.expr.conformance.proto3", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)", - type: "map(string, dyn)", - }, - { - original: { - name: "field_read_proto3_unset", - description: "Not a wrapper type, so doesn't convert to null.", - expr: "TestAllTypes{}.single_struct", - container: "cel.expr.conformance.proto3", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)", - type: "map(string, dyn)", - }, - ], - }, - { - name: "value_null", - tests: [ - { - original: { - name: "literal", - expr: "Value{null_value: NullValue.NULL_VALUE}", - container: "google.protobuf", - value: { nullValue: null }, - }, - ast: "Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "literal_no_field_access", - expr: "Value{null_value: NullValue.NULL_VALUE}.null_value", - disableCheck: true, - container: "google.protobuf", - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.null_value^#*expr.Expr_SelectExpr#", - checkedAst: - "google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value.null_value~dyn", - type: "dyn", - }, - { - original: { - name: "literal_unset", - expr: "google.protobuf.Value{}", - value: { nullValue: null }, - }, - ast: "google.protobuf.Value{}^#*expr.Expr_StructExpr#", - checkedAst: "google.protobuf.Value{}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Value" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Value", - value: null, - }, - }, - }, - }, - value: { nullValue: null }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~dyn^x", - type: "dyn", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_value: null}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: null, - }, - }, - }, - ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_value: null}.single_value", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_read_proto2_unset", - expr: "TestAllTypes{}.single_value", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_value: null}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: null, - }, - }, - }, - ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_value: null}.single_value", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_read_proto3_unset", - expr: "TestAllTypes{}.single_value", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - ], - }, - { - name: "value_number", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Value{number_value: 12.5}", - value: { doubleValue: 12.5 }, - }, - ast: "google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Value{number_value: 12.5}.number_value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.number_value^#*expr.Expr_SelectExpr#", - checkedAst: - "google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value.number_value~dyn", - type: "dyn", - }, - { - original: { - name: "literal_zero", - expr: "google.protobuf.Value{number_value: 0.0}", - value: { doubleValue: 0 }, - }, - ast: "google.protobuf.Value{\n number_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n number_value:0~double\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Value" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Value", - value: -26.375, - }, - }, - }, - }, - value: { doubleValue: -26.375 }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~dyn^x", - type: "dyn", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_value: 7e23}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: 7e23, - }, - }, - }, - ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_zero", - expr: "TestAllTypes{single_value: 0.0}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_value: 7e23}.single_value", - container: "cel.expr.conformance.proto2", - value: { doubleValue: 7e23 }, - }, - ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_value: 0.0}.single_value", - container: "cel.expr.conformance.proto2", - value: { doubleValue: 0 }, - }, - ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_value: 7e23}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: 7e23, - }, - }, - }, - ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_zero", - expr: "TestAllTypes{single_value: 0.0}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: 0, - }, - }, - }, - ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_value: 7e23}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 7e23 }, - }, - ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_read_proto3_zero", - expr: "TestAllTypes{single_value: 0.0}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 0 }, - }, - ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - ], - }, - { - name: "value_string", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Value{string_value: 'foo'}", - value: { stringValue: "foo" }, - }, - ast: 'google.protobuf.Value{\n string_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.Value{\n string_value:"foo"~string\n}~dyn^google.protobuf.Value', - type: "dyn", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Value{string_value: 'foo'}.string_value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.Value{\n string_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.string_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'google.protobuf.Value{\n string_value:"foo"~string\n}~dyn^google.protobuf.Value.string_value~dyn', - type: "dyn", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.Value{string_value: ''}", - value: { stringValue: "" }, - }, - ast: 'google.protobuf.Value{\n string_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.Value{\n string_value:""~string\n}~dyn^google.protobuf.Value', - type: "dyn", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Value" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Value", - value: "bar", - }, - }, - }, - }, - value: { stringValue: "bar" }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~dyn^x", - type: "dyn", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_value: 'baz'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: "baz", - }, - }, - }, - ast: 'TestAllTypes{\n single_value:"baz"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:"baz"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{single_value: ''}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: "", - }, - }, - }, - ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_value: 'bletch'}.single_value", - container: "cel.expr.conformance.proto2", - value: { stringValue: "bletch" }, - }, - ast: 'TestAllTypes{\n single_value:"bletch"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:"bletch"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_read_proto2_zero", - expr: "TestAllTypes{single_value: ''}.single_value", - container: "cel.expr.conformance.proto2", - value: { stringValue: "" }, - }, - ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_value: 'baz'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: "baz", - }, - }, - }, - ast: 'TestAllTypes{\n single_value:"baz"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:"baz"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{single_value: ''}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: "", - }, - }, - }, - ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_value: 'bletch'}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "bletch" }, - }, - ast: 'TestAllTypes{\n single_value:"bletch"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:"bletch"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_read_proto3_zero", - expr: "TestAllTypes{single_value: ''}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "" }, - }, - ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - ], - }, - { - name: "value_bool", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Value{bool_value: true}", - value: { boolValue: true }, - }, - ast: "google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Value{bool_value: true}.bool_value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.bool_value^#*expr.Expr_SelectExpr#", - checkedAst: - "google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value.bool_value~dyn", - type: "dyn", - }, - { - original: { - name: "literal_false", - expr: "google.protobuf.Value{bool_value: false}", - value: { boolValue: false }, - }, - ast: "google.protobuf.Value{\n bool_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n bool_value:false~bool\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Value" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Value", - value: true, - }, - }, - }, - }, - value: { boolValue: true }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~dyn^x", - type: "dyn", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_value: true}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: true, - }, - }, - }, - ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_false", - expr: "TestAllTypes{single_value: false}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: false, - }, - }, - }, - ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_value: true}.single_value", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_read_proto2_false", - expr: "TestAllTypes{single_value: false}.single_value", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_value: true}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: true, - }, - }, - }, - ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_false", - expr: "TestAllTypes{single_value: false}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: false, - }, - }, - }, - ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_value: true}.single_value", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_read_proto3_false", - expr: "TestAllTypes{single_value: false}.single_value", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - ], - }, - { - name: "value_struct", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}", - value: { - mapValue: { - entries: [ - { key: { stringValue: "a" }, value: { doubleValue: 1 } }, - { - key: { stringValue: "b" }, - value: { stringValue: "two" }, - }, - ], - }, - }, - }, - ast: 'google.protobuf.Value{\n struct_value:{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.Value{\n struct_value:{\n "a"~string:1~double,\n "b"~string:"two"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value', - type: "dyn", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}.struct_value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.Value{\n struct_value:{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.struct_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'google.protobuf.Value{\n struct_value:{\n "a"~string:1~double,\n "b"~string:"two"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value.struct_value~dyn', - type: "dyn", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.Value{struct_value: {}}", - value: { mapValue: {} }, - }, - ast: "google.protobuf.Value{\n struct_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n struct_value:{}~map(string, dyn)\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Value" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Value", - value: { x: null, y: false }, - }, - }, - }, - }, - value: { - mapValue: { - entries: [ - { key: { stringValue: "x" }, value: { nullValue: null } }, - { - key: { stringValue: "y" }, - value: { boolValue: false }, - }, - ], - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~dyn^x", - type: "dyn", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: { deux: 2, un: 1 }, - }, - }, - }, - ast: 'TestAllTypes{\n single_value:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{single_value: {}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: {}, - }, - }, - }, - ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_value: {'i': true}}.single_value", - container: "cel.expr.conformance.proto2", - value: { - mapValue: { - entries: [ - { key: { stringValue: "i" }, value: { boolValue: true } }, - ], - }, - }, - }, - ast: 'TestAllTypes{\n single_value:{\n "i"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n "i"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_read_proto2_empty", - expr: "TestAllTypes{single_value: {}}.single_value", - container: "cel.expr.conformance.proto2", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: { deux: 2, un: 1 }, - }, - }, - }, - ast: 'TestAllTypes{\n single_value:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{single_value: {}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: {}, - }, - }, - }, - ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_value: {'i': true}}.single_value", - container: "cel.expr.conformance.proto3", - value: { - mapValue: { - entries: [ - { key: { stringValue: "i" }, value: { boolValue: true } }, - ], - }, - }, - }, - ast: 'TestAllTypes{\n single_value:{\n "i"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n "i"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_read_proto3_empty", - expr: "TestAllTypes{single_value: {}}.single_value", - container: "cel.expr.conformance.proto3", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - ], - }, - { - name: "value_list", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Value{list_value: ['a', 3.0]}", - value: { - listValue: { - values: [{ stringValue: "a" }, { doubleValue: 3 }], - }, - }, - }, - ast: 'google.protobuf.Value{\n list_value:[\n "a"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.Value{\n list_value:[\n "a"~string,\n 3~double\n ]~list(dyn)\n}~dyn^google.protobuf.Value', - type: "dyn", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Value{list_value: []}.list_value", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: "google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", - checkedAst: - "google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value.list_value~dyn", - type: "dyn", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.Value{list_value: []}", - value: { listValue: {} }, - }, - ast: "google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value", - type: "dyn", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Value" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Value", - value: [1, true, "hi"], - }, - }, - }, - }, - value: { - listValue: { - values: [ - { doubleValue: 1 }, - { boolValue: true }, - { stringValue: "hi" }, - ], - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~dyn^x", - type: "dyn", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_value: ['un', 1.0]}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: ["un", 1], - }, - }, - }, - ast: 'TestAllTypes{\n single_value:[\n "un"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n "un"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_assign_proto2_empty", - expr: "TestAllTypes{single_value: []}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: [], - }, - }, - }, - ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_value: ['i', true]}.single_value", - container: "cel.expr.conformance.proto2", - value: { - listValue: { - values: [{ stringValue: "i" }, { boolValue: true }], - }, - }, - }, - ast: 'TestAllTypes{\n single_value:[\n "i"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n "i"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_read_proto2_empty", - expr: "TestAllTypes{single_value: []}.single_value", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_value: ['un', 1.0]}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: ["un", 1], - }, - }, - }, - ast: 'TestAllTypes{\n single_value:[\n "un"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n "un"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_assign_proto3_empty", - expr: "TestAllTypes{single_value: []}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: [], - }, - }, - }, - ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_value: ['i', true]}.single_value", - container: "cel.expr.conformance.proto3", - value: { - listValue: { - values: [{ stringValue: "i" }, { boolValue: true }], - }, - }, - }, - ast: 'TestAllTypes{\n single_value:[\n "i"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n "i"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "field_read_proto3_empty", - expr: "TestAllTypes{single_value: []}.single_value", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - ], - }, - { - name: "any", - tests: [ - { - original: { - name: "literal", - expr: "google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 150, - }, - }, - }, - ast: 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\b\\x96\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\b\\x96\\x01"~bytes\n}~any^google.protobuf.Any', - type: "any", - }, - { - original: { - name: "literal_no_field_access", - expr: "google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}.type_url", - disableCheck: true, - evalError: { errors: [{ message: "no_matching_overload" }] }, - }, - ast: 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\b\\x96\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.type_url^#*expr.Expr_SelectExpr#', - checkedAst: - 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\b\\x96\\x01"~bytes\n}~any^google.protobuf.Any.type_url~dyn', - type: "dyn", - }, - { - original: { - name: "literal_empty", - expr: "google.protobuf.Any{}", - evalError: { errors: [{ message: "conversion" }] }, - }, - ast: "google.protobuf.Any{}^#*expr.Expr_StructExpr#", - checkedAst: "google.protobuf.Any{}~any^google.protobuf.Any", - type: "any", - }, - { - original: { - name: "var", - expr: "x", - typeEnv: [ - { - name: "x", - ident: { type: { messageType: "google.protobuf.Any" } }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Any", - value: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 150, - }, - }, - }, - }, - }, - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 150, - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#", - checkedAst: "x~any^x", - type: "any", - }, - { - original: { - name: "field_assign_proto2", - expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleAny: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 150, - }, - }, - }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "field_read_proto2", - expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 150, - }, - }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "field_assign_proto3", - expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleAny: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 150, - }, - }, - }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "field_read_proto3", - expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 150, - }, - }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - ], - }, - { - name: "complex", - tests: [ - { - original: { - name: "any_list_map", - expr: "TestAllTypes{single_any: [{'almost': 'done'}]}.single_any", - container: "cel.expr.conformance.proto3", - value: { - listValue: { - values: [ - { - mapValue: { - entries: [ - { - key: { stringValue: "almost" }, - value: { stringValue: "done" }, - }, - ], - }, - }, - ], - }, - }, - }, - ast: 'TestAllTypes{\n single_any:[\n {\n "almost"^#*expr.Constant_StringValue#:"done"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_any:[\n {\n "almost"~string:"done"~string\n }~map(string, string)\n ]~list(map(string, string))\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any', - type: "any", - }, - ], - }, - ], - }, - { - name: "encoders_ext", - suites: [ - { - name: "encode", - tests: [ - { - original: { - name: "hello", - expr: "base64.encode(b'hello')", - value: { stringValue: "aGVsbG8=" }, - }, - ast: 'base64^#*expr.Expr_IdentExpr#.encode(\n b"hello"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'base64.encode(\n b"hello"~bytes\n)~string^base64_encode_bytes', - type: "string", - }, - ], - }, - { - name: "decode", - tests: [ - { - original: { - name: "hello", - expr: "base64.decode('aGVsbG8=')", - value: { bytesValue: "aGVsbG8=" }, - }, - ast: 'base64^#*expr.Expr_IdentExpr#.decode(\n "aGVsbG8="^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'base64.decode(\n "aGVsbG8="~string\n)~bytes^base64_decode_string', - type: "bytes", - }, - { - original: { - name: "hello_without_padding", - expr: "base64.decode('aGVsbG8')", - value: { bytesValue: "aGVsbG8=" }, - }, - ast: 'base64^#*expr.Expr_IdentExpr#.decode(\n "aGVsbG8"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'base64.decode(\n "aGVsbG8"~string\n)~bytes^base64_decode_string', - type: "bytes", - }, - ], - }, - { - name: "round_trip", - tests: [ - { - original: { - name: "hello", - expr: "base64.decode(base64.encode(b'Hello World!'))", - value: { bytesValue: "SGVsbG8gV29ybGQh" }, - }, - ast: 'base64^#*expr.Expr_IdentExpr#.decode(\n base64^#*expr.Expr_IdentExpr#.encode(\n b"Hello World!"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'base64.decode(\n base64.encode(\n b"Hello World!"~bytes\n )~string^base64_encode_bytes\n)~bytes^base64_decode_string', - type: "bytes", - }, - ], - }, - ], - }, - { - name: "enums", - suites: [ - { - name: "legacy_proto2", - tests: [ - { - original: { - name: "literal_global", - expr: "GlobalEnum.GAZ", - container: "cel.expr.conformance.proto2", - value: { int64Value: "2" }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ", - type: "int", - }, - { - original: { - name: "literal_nested", - expr: "TestAllTypes.NestedEnum.BAR", - container: "cel.expr.conformance.proto2", - value: { int64Value: "1" }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", - type: "int", - }, - { - original: { - name: "literal_zero", - expr: "GlobalEnum.GOO", - container: "cel.expr.conformance.proto2", - value: { int64Value: "0" }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO", - type: "int", - }, - { - original: { - name: "comparison", - expr: "GlobalEnum.GAR == 1", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "arithmetic", - expr: "TestAllTypes.NestedEnum.BAR + 3", - container: "cel.expr.conformance.proto2", - value: { int64Value: "4" }, - }, - ast: "_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "type_global", - expr: "type(GlobalEnum.GOO)", - container: "cel.expr.conformance.proto2", - value: { typeValue: "int" }, - }, - ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "type_nested", - expr: "type(TestAllTypes.NestedEnum.BAZ)", - container: "cel.expr.conformance.proto2", - value: { typeValue: "int" }, - }, - ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "select_default", - expr: "TestAllTypes{}.standalone_enum", - container: "cel.expr.conformance.proto2", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int", - type: "int", - }, - { - original: { - name: "field_type", - expr: "type(TestAllTypes{}.standalone_enum)", - container: "cel.expr.conformance.proto2", - value: { typeValue: "int" }, - }, - ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "assign_standalone_name", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - standaloneEnum: "BAZ", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int", - expr: "TestAllTypes{standalone_enum: 1}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - standaloneEnum: "BAR", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int_too_big", - expr: "TestAllTypes{standalone_enum: 5000000000}", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int_too_neg", - expr: "TestAllTypes{standalone_enum: -7000000000}", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "access_repeated_enum", - expr: "TestAllTypes{}.repeated_nested_enum", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)", - type: "list(int)", - }, - { - original: { - name: "assign_repeated_enum", - expr: "TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - repeatedNestedEnum: ["FOO", "BAR"], - }, - }, - }, - ast: "TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "list_enum_as_list_int", - expr: "0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "enum_as_int", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list", - type: "bool", - }, - ], - }, - { - name: "legacy_proto3", - tests: [ - { - original: { - name: "literal_global", - expr: "GlobalEnum.GAZ", - container: "cel.expr.conformance.proto3", - value: { int64Value: "2" }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ", - type: "int", - }, - { - original: { - name: "literal_nested", - expr: "TestAllTypes.NestedEnum.BAR", - container: "cel.expr.conformance.proto3", - value: { int64Value: "1" }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR", - type: "int", - }, - { - original: { - name: "literal_zero", - expr: "GlobalEnum.GOO", - container: "cel.expr.conformance.proto3", - value: { int64Value: "0" }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO", - type: "int", - }, - { - original: { - name: "comparison", - expr: "GlobalEnum.GAR == 1", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "arithmetic", - expr: "TestAllTypes.NestedEnum.BAR + 3", - container: "cel.expr.conformance.proto3", - value: { int64Value: "4" }, - }, - ast: "_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "type_global", - expr: "type(GlobalEnum.GOO)", - container: "cel.expr.conformance.proto3", - value: { typeValue: "int" }, - }, - ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "type_nested", - expr: "type(TestAllTypes.NestedEnum.BAZ)", - container: "cel.expr.conformance.proto3", - value: { typeValue: "int" }, - }, - ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "select_default", - expr: "TestAllTypes{}.standalone_enum", - container: "cel.expr.conformance.proto3", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int", - type: "int", - }, - { - original: { - name: "select", - expr: "x.standalone_enum", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - container: "cel.expr.conformance.proto3", - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: "BAZ", - }, - }, - }, - }, - value: { int64Value: "2" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", - type: "int", - }, - { - original: { - name: "select_big", - expr: "x.standalone_enum", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - container: "cel.expr.conformance.proto3", - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: 108, - }, - }, - }, - }, - value: { int64Value: "108" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", - type: "int", - }, - { - original: { - name: "select_neg", - expr: "x.standalone_enum", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - container: "cel.expr.conformance.proto3", - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: -3, - }, - }, - }, - }, - value: { int64Value: "-3" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", - type: "int", - }, - { - original: { - name: "field_type", - expr: "type(TestAllTypes{}.standalone_enum)", - container: "cel.expr.conformance.proto3", - value: { typeValue: "int" }, - }, - ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "assign_standalone_name", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: "BAZ", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int", - expr: "TestAllTypes{standalone_enum: 1}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: "BAR", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int_big", - expr: "TestAllTypes{standalone_enum: 99}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: 99, - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:99^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:99~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int_neg", - expr: "TestAllTypes{standalone_enum: -1}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: -1, - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int_too_big", - expr: "TestAllTypes{standalone_enum: 5000000000}", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int_too_neg", - expr: "TestAllTypes{standalone_enum: -7000000000}", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "access_repeated_enum", - expr: "TestAllTypes{}.repeated_nested_enum", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)", - type: "list(int)", - }, - { - original: { - name: "assign_repeated_enum", - expr: "TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - repeatedNestedEnum: ["FOO", "BAR"], - }, - }, - }, - ast: "TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "list_enum_as_list_int", - expr: "0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "enum_as_int", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list", - type: "bool", - }, - ], - }, - { - name: "strong_proto2", - tests: [ - { - original: { - name: "literal_global", - expr: "GlobalEnum.GAZ", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.GlobalEnum", - value: 2, - }, - }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ", - type: "int", - }, - { - original: { - name: "literal_nested", - expr: "TestAllTypes.NestedEnum.BAR", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - value: 1, - }, - }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", - type: "int", - }, - { - original: { - name: "literal_zero", - expr: "GlobalEnum.GOO", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { type: "cel.expr.conformance.proto2.GlobalEnum" }, - }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO", - type: "int", - }, - { - original: { - name: "comparison_true", - expr: "GlobalEnum.GAR == GlobalEnum.GAR", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "comparison_false", - expr: "GlobalEnum.GAR == GlobalEnum.GAZ", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "type_global", - expr: "type(GlobalEnum.GOO)", - container: "cel.expr.conformance.proto2", - value: { typeValue: "cel.expr.conformance.proto2.GlobalEnum" }, - }, - ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "type_nested", - expr: "type(TestAllTypes.NestedEnum.BAZ)", - container: "cel.expr.conformance.proto2", - value: { - typeValue: - "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - }, - }, - ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "select_default", - expr: "TestAllTypes{}.standalone_enum", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int", - type: "int", - }, - { - original: { - name: "field_type", - expr: "type(TestAllTypes{}.standalone_enum)", - container: "cel.expr.conformance.proto2", - value: { - typeValue: - "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - }, - }, - ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "assign_standalone_name", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - standaloneEnum: "BAZ", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - standaloneEnum: "BAR", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - error: - "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^", - }, - { - original: { - name: "convert_symbol_to_int", - expr: "int(GlobalEnum.GAZ)", - container: "cel.expr.conformance.proto2", - value: { int64Value: "2" }, - }, - ast: "int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~int^int64_to_int64", - type: "int", - }, - { - original: { - name: "convert_unnamed_to_int", - description: "Disable check - missing way to declare enums.", - expr: "int(x)", - disableCheck: true, - bindings: { - x: { - value: { - enumValue: { - type: "cel.expr.conformance.proto2.GlobalEnum", - value: 444, - }, - }, - }, - }, - value: { int64Value: "444" }, - }, - ast: "int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^", - }, - { - original: { - name: "convert_int_inrange", - expr: "TestAllTypes.NestedEnum(2)", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - value: 2, - }, - }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(2)\n | .......................^", - }, - { - original: { - name: "convert_int_big", - expr: "TestAllTypes.NestedEnum(20000)", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - value: 20000, - }, - }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(20000)\n | .......................^", - }, - { - original: { - name: "convert_int_neg", - expr: "GlobalEnum(-33)", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.GlobalEnum", - value: -33, - }, - }, - }, - ast: "GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto2')\n | GlobalEnum(-33)\n | ..........^", - }, - { - original: { - name: "convert_int_too_big", - expr: "TestAllTypes.NestedEnum(5000000000)", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^", - }, - { - original: { - name: "convert_int_too_neg", - expr: "TestAllTypes.NestedEnum(-7000000000)", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^", - }, - { - original: { - name: "convert_string", - expr: "TestAllTypes.NestedEnum('BAZ')", - container: "cel.expr.conformance.proto2", - value: { - enumValue: { - type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", - value: 2, - }, - }, - }, - ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BAZ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^", - }, - { - original: { - name: "convert_string_bad", - expr: "TestAllTypes.NestedEnum('BLETCH')", - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "invalid" }] }, - }, - ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BLETCH"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^", - }, - ], - }, - { - name: "strong_proto3", - tests: [ - { - original: { - name: "literal_global", - expr: "GlobalEnum.GAZ", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.GlobalEnum", - value: 2, - }, - }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ", - type: "int", - }, - { - original: { - name: "literal_nested", - expr: "TestAllTypes.NestedEnum.BAR", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: 1, - }, - }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR", - type: "int", - }, - { - original: { - name: "literal_zero", - expr: "GlobalEnum.GOO", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { type: "cel.expr.conformance.proto3.GlobalEnum" }, - }, - }, - ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO", - type: "int", - }, - { - original: { - name: "comparison_true", - expr: "GlobalEnum.GAR == GlobalEnum.GAR", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "comparison_false", - expr: "GlobalEnum.GAR == GlobalEnum.GAZ", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "type_global", - expr: "type(GlobalEnum.GOO)", - container: "cel.expr.conformance.proto3", - value: { typeValue: "cel.expr.conformance.proto3.GlobalEnum" }, - }, - ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "type_nested", - expr: "type(TestAllTypes.NestedEnum.BAZ)", - container: "cel.expr.conformance.proto3", - value: { - typeValue: - "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - }, - }, - ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "select_default", - expr: "TestAllTypes{}.standalone_enum", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int", - type: "int", - }, - { - original: { - name: "select", - expr: "x.standalone_enum", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - container: "cel.expr.conformance.proto3", - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: "BAZ", - }, - }, - }, - }, - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: 2, - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", - type: "int", - }, - { - original: { - name: "select_big", - expr: "x.standalone_enum", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - container: "cel.expr.conformance.proto3", - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: 108, - }, - }, - }, - }, - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: 108, - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", - type: "int", - }, - { - original: { - name: "select_neg", - expr: "x.standalone_enum", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - container: "cel.expr.conformance.proto3", - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: -3, - }, - }, - }, - }, - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: -3, - }, - }, - }, - ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", - type: "int", - }, - { - original: { - name: "field_type", - expr: "type(TestAllTypes{}.standalone_enum)", - container: "cel.expr.conformance.proto3", - value: { - typeValue: - "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - }, - }, - ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type", - type: "type(int)", - }, - { - original: { - name: "assign_standalone_name", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: "BAZ", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "assign_standalone_int", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: "BAR", - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - error: - "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^", - }, - { - original: { - name: "assign_standalone_int_big", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: 99, - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 99^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - error: - "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}\n | .....................................................^", - }, - { - original: { - name: "assign_standalone_int_neg", - expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: -1, - }, - }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - error: - "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}\n | .....................................................^", - }, - { - original: { - name: "convert_symbol_to_int", - expr: "int(GlobalEnum.GAZ)", - container: "cel.expr.conformance.proto3", - value: { int64Value: "2" }, - }, - ast: "int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~int^int64_to_int64", - type: "int", - }, - { - original: { - name: "convert_unnamed_to_int", - description: "Disable check - missing way to declare enums.", - expr: "int(x)", - disableCheck: true, - bindings: { - x: { - value: { - enumValue: { - type: "cel.expr.conformance.proto3.GlobalEnum", - value: 444, - }, - }, - }, - }, - value: { int64Value: "444" }, - }, - ast: "int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^", - }, - { - original: { - name: "convert_unnamed_to_int_select", - expr: "int(x.standalone_enum)", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - standaloneEnum: -987, - }, - }, - }, - }, - value: { int64Value: "-987" }, - }, - ast: "int(\n x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int\n)~int^int64_to_int64", - type: "int", - }, - { - original: { - name: "convert_int_inrange", - expr: "TestAllTypes.NestedEnum(2)", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: 2, - }, - }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(2)\n | .......................^", - }, - { - original: { - name: "convert_int_big", - expr: "TestAllTypes.NestedEnum(20000)", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: 20000, - }, - }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(20000)\n | .......................^", - }, - { - original: { - name: "convert_int_neg", - expr: "GlobalEnum(-33)", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.GlobalEnum", - value: -33, - }, - }, - }, - ast: "GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto3')\n | GlobalEnum(-33)\n | ..........^", - }, - { - original: { - name: "convert_int_too_big", - expr: "TestAllTypes.NestedEnum(5000000000)", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^", - }, - { - original: { - name: "convert_int_too_neg", - expr: "TestAllTypes.NestedEnum(-7000000000)", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "range" }] }, - }, - ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^", - }, - { - original: { - name: "convert_string", - expr: "TestAllTypes.NestedEnum('BAZ')", - container: "cel.expr.conformance.proto3", - value: { - enumValue: { - type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", - value: 2, - }, - }, - }, - ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BAZ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^", - }, - { - original: { - name: "convert_string_bad", - expr: "TestAllTypes.NestedEnum('BLETCH')", - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "invalid" }] }, - }, - ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BLETCH"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^", - }, - ], - }, - ], - }, - { - name: "fields", - suites: [ - { - name: "map_fields", - tests: [ - { - original: { - name: "map_key_int64", - expr: "{0:1,2:2,5:true}[5]", - value: { boolValue: true }, - }, - ast: "_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:true~bool\n }~map(int, dyn),\n 5~int\n)~dyn^index_map", - type: "dyn", - }, - { - original: { - name: "map_key_uint64", - expr: "{0u:1u,2u:'happy',5u:3u}[2u]", - value: { stringValue: "happy" }, - }, - ast: '_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:"happy"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:"happy"~string,\n 5u~uint:3u~uint\n }~map(uint, dyn),\n 2u~uint\n)~dyn^index_map', - type: "dyn", - }, - { - original: { - name: "map_key_string", - expr: "{'name':100u}['name']", - value: { uint64Value: "100" }, - }, - ast: '_[_](\n {\n "name"^#*expr.Constant_StringValue#:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "name"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n "name"~string:100u~uint\n }~map(string, uint),\n "name"~string\n)~uint^index_map', - type: "uint", - }, - { - original: { - name: "map_key_bool", - expr: "{true:5}[true]", - value: { int64Value: "5" }, - }, - ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n true~bool:5~int\n }~map(bool, int),\n true~bool\n)~int^index_map", - type: "int", - }, - { - original: { - name: "map_key_mixed_type", - expr: "{true:1,2:2,5u:3}[true]", - value: { int64Value: "1" }, - }, - ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n true~bool:1~int,\n 2~int:2~int,\n 5u~uint:3~int\n }~map(dyn, int),\n true~bool\n)~int^index_map", - type: "int", - }, - { - original: { - name: "map_key_mixed_numbers_double_key", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[3.0]", - value: { doubleValue: 3 }, - }, - ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3~double\n)~double^index_map", - type: "double", - }, - { - original: { - name: "map_key_mixed_numbers_lossy_double_key", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[3.1]", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3.1~double\n)~double^index_map", - type: "double", - }, - { - original: { - name: "map_key_mixed_numbers_uint_key", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[2u]", - value: { doubleValue: 2 }, - }, - ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 2u~uint\n)~double^index_map", - type: "double", - }, - { - original: { - name: "map_key_mixed_numbers_int_key", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[1]", - value: { doubleValue: 1 }, - }, - ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 1~int\n)~double^index_map", - type: "double", - }, - { - original: { - name: "map_field_access", - expr: "x.name", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "INT64" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "name" }, - value: { int64Value: "1024" }, - }, - ], - }, - }, - }, - }, - value: { int64Value: "1024" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#", - checkedAst: "x~map(string, int)^x.name~int", - type: "int", - }, - { - original: { - name: "map_no_such_key", - expr: "{0:1,2:2,5:3}[1]", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: "_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n)~int^index_map", - type: "int", - }, - { - original: { - name: "map_no_such_key_or_false", - expr: "dyn({0:1,2:2,5:3}[1]) || false", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: "_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "map_no_such_key_or_true", - expr: "dyn({0:1,2:2,5:3}[1]) || true", - value: { boolValue: true }, - }, - ast: "_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "map_no_such_key_and_false", - expr: "dyn({0:1,2:2,5:3}[1]) \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "map_no_such_key_and_true", - expr: "dyn({0:1,2:2,5:3}[1]) \u0026\u0026 true", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "map_bad_key_type", - expr: "{0:1,2:2,5:3}[dyn(b'')]", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: '_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n)~int^index_map', - type: "int", - }, - { - original: { - name: "map_bad_key_type_or_false", - expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) || false", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: '_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or', - type: "bool", - }, - { - original: { - name: "map_bad_key_type_or_true", - expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) || true", - value: { boolValue: true }, - }, - ast: '_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or', - type: "bool", - }, - { - original: { - name: "map_bad_key_type_and_false", - expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and', - type: "bool", - }, - { - original: { - name: "map_bad_key_type_and_true", - expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 true", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and', - type: "bool", - }, - { - original: { - name: "map_field_select_no_such_key", - expr: "x.name", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "holiday" }, - value: { stringValue: "field" }, - }, - ], - }, - }, - }, - }, - evalError: { errors: [{ message: "no such key: 'name'" }] }, - }, - ast: "x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#", - checkedAst: "x~map(string, string)^x.name~string", - type: "string", - }, - { - original: { - name: "map_field_select_no_such_key_or_false", - expr: "dyn(x.name) || false", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "holiday" }, - value: { stringValue: "field" }, - }, - ], - }, - }, - }, - }, - evalError: { errors: [{ message: "no such key: 'name'" }] }, - }, - ast: "_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "map_field_select_no_such_key_or_true", - expr: "dyn(x.name) || true", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "holiday" }, - value: { stringValue: "field" }, - }, - ], - }, - }, - }, - }, - value: { boolValue: true }, - }, - ast: "_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "map_field_select_no_such_key_and_false", - expr: "dyn(x.name) \u0026\u0026 false", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "holiday" }, - value: { stringValue: "field" }, - }, - ], - }, - }, - }, - }, - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "map_field_select_no_such_key_and_true", - expr: "dyn(x.name) \u0026\u0026 true", - typeEnv: [ - { - name: "x", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - x: { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "holiday" }, - value: { stringValue: "field" }, - }, - ], - }, - }, - }, - }, - evalError: { errors: [{ message: "no such key: 'name'" }] }, - }, - ast: "_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "map_value_null", - expr: "{true:null}[true]", - value: { nullValue: null }, - }, - ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n true~bool:null~null\n }~map(bool, null),\n true~bool\n)~null^index_map", - type: "null", - }, - { - original: { - name: "map_value_bool", - expr: "{27:false}[27]", - value: { boolValue: false }, - }, - ast: "_[_](\n {\n 27^#*expr.Constant_Int64Value#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 27^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 27~int:false~bool\n }~map(int, bool),\n 27~int\n)~bool^index_map", - type: "bool", - }, - { - original: { - name: "map_value_string", - expr: "{'n':'x'}['n']", - value: { stringValue: "x" }, - }, - ast: '_[_](\n {\n "n"^#*expr.Constant_StringValue#:"x"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "n"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n "n"~string:"x"~string\n }~map(string, string),\n "n"~string\n)~string^index_map', - type: "string", - }, - { - original: { - name: "map_value_float", - expr: "{3:15.15}[3]", - value: { doubleValue: 15.15 }, - }, - ast: "_[_](\n {\n 3^#*expr.Constant_Int64Value#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 3~int:15.15~double\n }~map(int, double),\n 3~int\n)~double^index_map", - type: "double", - }, - { - original: { - name: "map_value_uint64", - expr: "{0u:1u,2u:2u,5u:3u}[0u]", - value: { uint64Value: "1" }, - }, - ast: "_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:2u~uint,\n 5u~uint:3u~uint\n }~map(uint, uint),\n 0u~uint\n)~uint^index_map", - type: "uint", - }, - { - original: { - name: "map_value_int64", - expr: "{true:1,false:2}[true]", - value: { int64Value: "1" }, - }, - ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n true~bool:1~int,\n false~bool:2~int\n }~map(bool, int),\n true~bool\n)~int^index_map", - type: "int", - }, - { - original: { - name: "map_value_bytes", - expr: "{0:b''}[0]", - value: { bytesValue: "" }, - }, - ast: '_[_](\n {\n 0^#*expr.Constant_Int64Value#:b""^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n 0~int:b""~bytes\n }~map(int, bytes),\n 0~int\n)~bytes^index_map', - type: "bytes", - }, - { - original: { - name: "map_value_list", - expr: "{0u:[1]}[0u]", - value: { listValue: { values: [{ int64Value: "1" }] } }, - }, - ast: "_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 0u~uint:[\n 1~int\n ]~list(int)\n }~map(uint, list(int)),\n 0u~uint\n)~list(int)^index_map", - type: "list(int)", - }, - { - original: { - name: "map_value_map", - expr: "{'map': {'k': 'v'}}['map']", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "k" }, - value: { stringValue: "v" }, - }, - ], - }, - }, - }, - ast: '_[_](\n {\n "map"^#*expr.Constant_StringValue#:{\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "map"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n "map"~string:{\n "k"~string:"v"~string\n }~map(string, string)\n }~map(string, map(string, string)),\n "map"~string\n)~map(string, string)^index_map', - type: "map(string, string)", - }, - { - original: { - name: "map_value_mix_type", - expr: "{'map': {'k': 'v'}, 'list': [1]}['map']", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "k" }, - value: { stringValue: "v" }, - }, - ], - }, - }, - }, - ast: '_[_](\n {\n "map"^#*expr.Constant_StringValue#:{\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#,\n "list"^#*expr.Constant_StringValue#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "map"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n "map"~string:{\n "k"~string:"v"~string\n }~map(string, string),\n "list"~string:[\n 1~int\n ]~list(int)\n }~map(string, dyn),\n "map"~string\n)~dyn^index_map', - type: "dyn", - }, - ], - }, - { - name: "map_has", - tests: [ - { - original: { - name: "has", - expr: "has({'a': 1, 'b': 2}.a)", - value: { boolValue: true }, - }, - ast: '{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "a"~string:1~int,\n "b"~string:2~int\n}~map(string, int).a~test-only~~bool', - type: "bool", - }, - { - original: { - name: "has_not", - expr: "has({'a': 1, 'b': 2}.c)", - value: { boolValue: false }, - }, - ast: '{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.c~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "a"~string:1~int,\n "b"~string:2~int\n}~map(string, int).c~test-only~~bool', - type: "bool", - }, - { - original: { - name: "has_empty", - expr: "has({}.a)", - value: { boolValue: false }, - }, - ast: "{}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: "{}~map(dyn, dyn).a~test-only~~bool", - type: "bool", - }, - ], - }, - { - name: "quoted_map_fields", - tests: [ - { - original: { - name: "field_access_slash", - expr: "{'/api/v1': true, '/api/v2': false}.`/api/v1`", - value: { boolValue: true }, - }, - error: - "ERROR: field_access_slash:1:37: unsupported syntax: '`'\n | {'/api/v1': true, '/api/v2': false}.`/api/v1`\n | ....................................^", - }, - { - original: { - name: "field_access_dash", - expr: "{'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'", - value: { boolValue: true }, - }, - error: - "ERROR: field_access_dash:1:61: unsupported syntax: '`'\n | {'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'\n | ............................................................^", - }, - { - original: { - name: "field_access_dot", - expr: "{'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`", - value: { int64Value: "32" }, - }, - error: - "ERROR: field_access_dot:1:34: unsupported syntax: '`'\n | {'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`\n | .................................^", - }, - { - original: { - name: "has_field_slash", - expr: "has({'/api/v1': true, '/api/v2': false}.`/api/v3`)", - value: { boolValue: false }, - }, - error: - "ERROR: has_field_slash:1:41: unsupported syntax: '`'\n | has({'/api/v1': true, '/api/v2': false}.`/api/v3`)\n | ........................................^", - }, - { - original: { - name: "has_field_dash", - expr: "has({'content-type': 'application/json', 'content-length': 145}.`content-type`)", - value: { boolValue: true }, - }, - error: - "ERROR: has_field_dash:1:65: unsupported syntax: '`'\n | has({'content-type': 'application/json', 'content-length': 145}.`content-type`)\n | ................................................................^", - }, - { - original: { - name: "has_field_dot", - expr: "has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)", - value: { boolValue: true }, - }, - error: - "ERROR: has_field_dot:1:38: unsupported syntax: '`'\n | has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)\n | .....................................^", - }, - ], - }, - { - name: "qualified_identifier_resolution", - tests: [ - { - original: { - name: "qualified_ident", - expr: "a.b.c", - typeEnv: [ - { name: "a.b.c", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { "a.b.c": { value: { stringValue: "yeah" } } }, - value: { stringValue: "yeah" }, - }, - ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", - checkedAst: "a.b.c~string^a.b.c", - type: "string", - }, - { - original: { - name: "map_field_select", - expr: "a.b.c", - typeEnv: [ - { - name: "a.b", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - "a.b": { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "c" }, - value: { stringValue: "yeah" }, - }, - ], - }, - }, - }, - }, - value: { stringValue: "yeah" }, - }, - ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", - checkedAst: "a.b~map(string, string)^a.b.c~string", - type: "string", - }, - { - original: { - name: "qualified_identifier_resolution_unchecked", - description: - "namespace resolution should try to find the longest prefix for the evaluator.", - expr: "a.b.c", - disableCheck: true, - typeEnv: [ - { name: "a.b.c", ident: { type: { primitive: "STRING" } } }, - { - name: "a.b", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - "a.b": { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "c" }, - value: { stringValue: "oops" }, - }, - ], - }, - }, - }, - "a.b.c": { value: { stringValue: "yeah" } }, - }, - value: { stringValue: "yeah" }, - }, - ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", - checkedAst: "a.b.c~string^a.b.c", - type: "string", - }, - { - original: { - name: "list_field_select_unsupported", - expr: "a.b.pancakes", - disableCheck: true, - typeEnv: [ - { - name: "a.b", - ident: { - type: { listType: { elemType: { primitive: "STRING" } } }, - }, - }, - ], - bindings: { - "a.b": { - value: { - listValue: { values: [{ stringValue: "pancakes" }] }, - }, - }, - }, - evalError: { - errors: [ - { - message: - "type 'list_type:\u003celem_type:\u003cprimitive:STRING \u003e \u003e ' does not support field selection", - }, - ], - }, - }, - ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.pancakes^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:4: type 'list(string)' does not support field selection\n | a.b.pancakes\n | ...^", - }, - { - original: { - name: "int64_field_select_unsupported", - expr: "a.pancakes", - disableCheck: true, - typeEnv: [ - { name: "a", ident: { type: { primitive: "INT64" } } }, - ], - bindings: { a: { value: { int64Value: "15" } } }, - evalError: { - errors: [ - { - message: - "type 'int64_type' does not support field selection", - }, - ], - }, - }, - ast: "a^#*expr.Expr_IdentExpr#.pancakes^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:2: type 'int' does not support field selection\n | a.pancakes\n | .^", - }, - { - original: { - name: "ident_with_longest_prefix_check", - description: - "namespace resolution should try to find the longest prefix for the checker.", - expr: "a.b.c", - typeEnv: [ - { name: "a.b.c", ident: { type: { primitive: "STRING" } } }, - { - name: "a.b", - ident: { - type: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "STRING" }, - }, - }, - }, - }, - ], - bindings: { - "a.b": { - value: { - mapValue: { - entries: [ - { - key: { stringValue: "c" }, - value: { stringValue: "oops" }, - }, - ], - }, - }, - }, - "a.b.c": { value: { stringValue: "yeah" } }, - }, - value: { stringValue: "yeah" }, - }, - ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", - checkedAst: "a.b.c~string^a.b.c", - type: "string", - }, - { - original: { - name: "map_key_float", - description: "map should not support float as the key.", - expr: "{3.3:15.15, 1.0: 5}[1.0]", - disableCheck: true, - evalError: { errors: [{ message: "unsupported key type" }] }, - }, - ast: "_[_](\n {\n 3.3^#*expr.Constant_DoubleValue#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_DoubleValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 3.3~double:15.15~double,\n 1~double:5~int\n }~map(double, dyn),\n 1~double\n)~dyn^index_map", - type: "dyn", - }, - { - original: { - name: "map_key_null", - description: "map should not support null as the key.", - expr: "{null:false}[null]", - disableCheck: true, - evalError: { errors: [{ message: "unsupported key type" }] }, - }, - ast: "_[_](\n {\n null^#*expr.Constant_NullValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n null~null:false~bool\n }~map(null, bool),\n null~null\n)~bool^index_map", - type: "bool", - }, - { - original: { - name: "map_value_repeat_key", - description: "map should not support repeated key.", - expr: "{true:1,false:2,true:3}[true]", - evalError: { - errors: [{ message: "Failed with repeated key" }], - }, - }, - ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n true~bool:1~int,\n false~bool:2~int,\n true~bool:3~int\n }~map(bool, int),\n true~bool\n)~int^index_map", - type: "int", - }, - { - original: { - name: "map_value_repeat_key_heterogeneous", - description: "map should not support repeated key.", - expr: "{0: 1, 0u: 2}[0.0]", - evalError: { - errors: [{ message: "Failed with repeated key" }], - }, - }, - ast: "_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 0u^#*expr.Constant_Uint64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n {\n 0~int:1~int,\n 0u~uint:2~int\n }~map(dyn, int),\n 0~double\n)~int^index_map", - type: "int", - }, - ], - }, - { - name: "in", - tests: [ - { - original: { - name: "empty", - expr: "7 in {}", - value: { boolValue: false }, - }, - ast: "@in(\n 7^#*expr.Constant_Int64Value#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: "@in(\n 7~int,\n {}~map(int, dyn)\n)~bool^in_map", - type: "bool", - }, - { - original: { - name: "singleton", - expr: "true in {true: 1}", - value: { boolValue: true }, - }, - ast: "@in(\n true^#*expr.Constant_BoolValue#,\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n true~bool,\n {\n true~bool:1~int\n }~map(bool, int)\n)~bool^in_map", - type: "bool", - }, - { - original: { - name: "present", - expr: "'George' in {'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}", - value: { boolValue: true }, - }, - ast: '@in(\n "George"^#*expr.Constant_StringValue#,\n {\n "John"^#*expr.Constant_StringValue#:"smart"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Paul"^#*expr.Constant_StringValue#:"cute"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "George"^#*expr.Constant_StringValue#:"quiet"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Ringo"^#*expr.Constant_StringValue#:"funny"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "George"~string,\n {\n "John"~string:"smart"~string,\n "Paul"~string:"cute"~string,\n "George"~string:"quiet"~string,\n "Ringo"~string:"funny"~string\n }~map(string, string)\n)~bool^in_map', - type: "bool", - }, - { - original: { - name: "absent", - expr: "'spider' in {'ant': 6, 'fly': 6, 'centipede': 100}", - value: { boolValue: false }, - }, - ast: '@in(\n "spider"^#*expr.Constant_StringValue#,\n {\n "ant"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "fly"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "centipede"^#*expr.Constant_StringValue#:100^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "spider"~string,\n {\n "ant"~string:6~int,\n "fly"~string:6~int,\n "centipede"~string:100~int\n }~map(string, int)\n)~bool^in_map', - type: "bool", - }, - { - original: { - name: "mixed_numbers_and_keys_present", - expr: "3.0 in {1: 1, 2: 2, 3u: 3} \u0026\u0026 2u in {1u: 1, 2: 2} \u0026\u0026 1 in {1u: 1, 2: 2}", - value: { boolValue: true }, - }, - ast: "_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2u^#*expr.Constant_Uint64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n )~bool^in_map,\n @in(\n 2u~uint,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n )~bool^logical_and,\n @in(\n 1~int,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "mixed_numbers_and_keys_absent", - expr: "3.1 in {1: 1, 2: 2, 3u: 3}", - value: { boolValue: false }, - }, - ast: "@in(\n 3.1^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n 3.1~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n)~bool^in_map", - type: "bool", - }, - ], - }, - ], - }, - { - name: "fp_math", - suites: [ - { - name: "fp_math", - tests: [ - { - original: { - name: "add_positive_positive", - expr: "4.25 + 15.25", - value: { doubleValue: 19.5 }, - }, - ast: "_+_(\n 4.25^#*expr.Constant_DoubleValue#,\n 15.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n 4.25~double,\n 15.25~double\n)~double^add_double", - type: "double", - }, - { - original: { - name: "add_positive_negative", - expr: "17.75 + (-7.75)", - value: { doubleValue: 10 }, - }, - ast: "_+_(\n 17.75^#*expr.Constant_DoubleValue#,\n -7.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n 17.75~double,\n -7.75~double\n)~double^add_double", - type: "double", - }, - { - original: { - name: "add_negative_negative", - expr: "-4.125 + (-2.125)", - value: { doubleValue: -6.25 }, - }, - ast: "_+_(\n -4.125^#*expr.Constant_DoubleValue#,\n -2.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n -4.125~double,\n -2.125~double\n)~double^add_double", - type: "double", - }, - { - original: { - name: "sub_positive_positive", - expr: "42.0 - 12.0", - value: { doubleValue: 30 }, - }, - ast: "_-_(\n 42^#*expr.Constant_DoubleValue#,\n 12^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_-_(\n 42~double,\n 12~double\n)~double^subtract_double", - type: "double", - }, - { - original: { - name: "sub_positive_negative", - expr: "42.875 - (-22.0)", - value: { doubleValue: 64.875 }, - }, - ast: "_-_(\n 42.875^#*expr.Constant_DoubleValue#,\n -22^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_-_(\n 42.875~double,\n -22~double\n)~double^subtract_double", - type: "double", - }, - { - original: { - name: "sub_negative_negative", - expr: "-4.875 - (-0.125)", - value: { doubleValue: -4.75 }, - }, - ast: "_-_(\n -4.875^#*expr.Constant_DoubleValue#,\n -0.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_-_(\n -4.875~double,\n -0.125~double\n)~double^subtract_double", - type: "double", - }, - { - original: { - name: "multiply_positive_positive", - expr: "42.5 * 0.2", - value: { doubleValue: 8.5 }, - }, - ast: "_*_(\n 42.5^#*expr.Constant_DoubleValue#,\n 0.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 42.5~double,\n 0.2~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "multiply_positive_negative", - expr: "40.75 * (-2.25)", - value: { doubleValue: -91.6875 }, - }, - ast: "_*_(\n 40.75^#*expr.Constant_DoubleValue#,\n -2.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 40.75~double,\n -2.25~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "multiply_negative_negative", - expr: "-3.0 * (-2.5)", - value: { doubleValue: 7.5 }, - }, - ast: "_*_(\n -3^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n -3~double,\n -2.5~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "divide_positive_positive", - expr: "0.0625 / 0.002", - value: { doubleValue: 31.25 }, - }, - ast: "_/_(\n 0.0625^#*expr.Constant_DoubleValue#,\n 0.002^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n 0.0625~double,\n 0.002~double\n)~double^divide_double", - type: "double", - }, - { - original: { - name: "divide_positive_negative", - expr: "-2.0 / 2.0", - value: { doubleValue: -1 }, - }, - ast: "_/_(\n -2^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n -2~double,\n 2~double\n)~double^divide_double", - type: "double", - }, - { - original: { - name: "divide_negative_negative", - expr: "-8.875 / (-0.0625)", - value: { doubleValue: 142 }, - }, - ast: "_/_(\n -8.875^#*expr.Constant_DoubleValue#,\n -0.0625^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n -8.875~double,\n -0.0625~double\n)~double^divide_double", - type: "double", - }, - { - original: { - name: "mod_not_support", - expr: "47.5 % 5.5", - disableCheck: true, - evalError: { - errors: [ - { - message: - "found no matching overload for '_%_' applied to '(double, double)'", - }, - ], - }, - }, - ast: "_%_(\n 47.5^#*expr.Constant_DoubleValue#,\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:6: found no matching overload for '_%_' applied to '(double, double)'\n | 47.5 % 5.5\n | .....^", - }, - { - original: { - name: "negative", - expr: "-(4.5)", - value: { doubleValue: -4.5 }, - }, - ast: "-_(\n 4.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n 4.5~double\n)~double^negate_double", - type: "double", - }, - { - original: { - name: "double_negative", - expr: "-(-1.25)", - value: { doubleValue: 1.25 }, - }, - ast: "-_(\n -1.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n -1.25~double\n)~double^negate_double", - type: "double", - }, - { - original: { - name: "negative_zero", - expr: "-(0.0)", - value: { doubleValue: 0 }, - }, - ast: "-_(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n 0~double\n)~double^negate_double", - type: "double", - }, - { - original: { - name: "divide_zero", - expr: "15.75 / 0.0", - value: { doubleValue: "Infinity" }, - }, - ast: "_/_(\n 15.75^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n 15.75~double,\n 0~double\n)~double^divide_double", - type: "double", - }, - { - original: { - name: "multiply_zero", - expr: "15.36 * 0.0", - value: { doubleValue: 0 }, - }, - ast: "_*_(\n 15.36^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 15.36~double,\n 0~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "add_left_identity", - expr: "0.0 + 1.75", - value: { doubleValue: 1.75 }, - }, - ast: "_+_(\n 0^#*expr.Constant_DoubleValue#,\n 1.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n 0~double,\n 1.75~double\n)~double^add_double", - type: "double", - }, - { - original: { - name: "add_right_identity", - expr: " 2.5 + 0.0", - value: { doubleValue: 2.5 }, - }, - ast: "_+_(\n 2.5^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n 2.5~double,\n 0~double\n)~double^add_double", - type: "double", - }, - { - original: { - name: "add_commutative", - expr: "7.5 + 1.5 == 1.5 + 7.5", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n 7.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 7.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n 7.5~double,\n 1.5~double\n )~double^add_double,\n _+_(\n 1.5~double,\n 7.5~double\n )~double^add_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "add_associative", - expr: "5.625 + (15.75 + 2.0) == (5.625 + 15.75) + 2.0", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n _+_(\n 15.75^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n 15.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n 5.625~double,\n _+_(\n 15.75~double,\n 2~double\n )~double^add_double\n )~double^add_double,\n _+_(\n _+_(\n 5.625~double,\n 15.75~double\n )~double^add_double,\n 2~double\n )~double^add_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "mul_left_identity", - expr: "1.0 * 45.25", - value: { doubleValue: 45.25 }, - }, - ast: "_*_(\n 1^#*expr.Constant_DoubleValue#,\n 45.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 1~double,\n 45.25~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "mul_right_identity", - expr: "-25.25 * 1.0", - value: { doubleValue: -25.25 }, - }, - ast: "_*_(\n -25.25^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n -25.25~double,\n 1~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "mul_commutative", - expr: "1.5 * 25.875 == 25.875 * 1.5", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 25.875^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25.875^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 1.5~double,\n 25.875~double\n )~double^multiply_double,\n _*_(\n 25.875~double,\n 1.5~double\n )~double^multiply_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "mul_associative", - expr: "1.5 * (23.625 * 0.75) == (1.5 * 23.625) * 0.75", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n _*_(\n 23.625^#*expr.Constant_DoubleValue#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 23.625^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 1.5~double,\n _*_(\n 23.625~double,\n 0.75~double\n )~double^multiply_double\n )~double^multiply_double,\n _*_(\n _*_(\n 1.5~double,\n 23.625~double\n )~double^multiply_double,\n 0.75~double\n )~double^multiply_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "add_mul_distribute", - expr: "5.75 * (1.5 + 2.5) == 5.75 * 1.5 + 5.75 * 2.5", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 5.75~double,\n _+_(\n 1.5~double,\n 2.5~double\n )~double^add_double\n )~double^multiply_double,\n _+_(\n _*_(\n 5.75~double,\n 1.5~double\n )~double^multiply_double,\n _*_(\n 5.75~double,\n 2.5~double\n )~double^multiply_double\n )~double^add_double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "fp_overflow_positive", - description: "DBL_MAX(2^1023) times two", - expr: "2.0 * 8.988466e+307 ", - value: { doubleValue: "Infinity" }, - }, - ast: "_*_(\n 2^#*expr.Constant_DoubleValue#,\n 8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 2~double,\n 8.988466e+307~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "fp_overflow_negative", - description: "-DBL_MAX(-2^1023) times two", - expr: "2.0 * -8.988466e+307 ", - value: { doubleValue: "-Infinity" }, - }, - ast: "_*_(\n 2^#*expr.Constant_DoubleValue#,\n -8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 2~double,\n -8.988466e+307~double\n)~double^multiply_double", - type: "double", - }, - { - original: { - name: "fp_underflow", - description: "DBL_MIN(2^-1074) divided by two", - expr: "1e-324 / 2.0", - value: { doubleValue: 0 }, - }, - ast: "_/_(\n 0^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n 0~double,\n 2~double\n)~double^divide_double", - type: "double", - }, - ], - }, - ], - }, - { - name: "integer_math", - suites: [ - { - name: "int64_math", - tests: [ - { - original: { - name: "add_positive_positive", - expr: "40 + 2", - value: { int64Value: "42" }, - }, - ast: "_+_(\n 40^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 40~int,\n 2~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "add_positive_negative", - expr: "42 + (-7)", - value: { int64Value: "35" }, - }, - ast: "_+_(\n 42^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 42~int,\n -7~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "add_negative_negative", - expr: "-4 + (-2)", - value: { int64Value: "-6" }, - }, - ast: "_+_(\n -4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n -4~int,\n -2~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "sub_positive_positive", - expr: "42 - 12", - value: { int64Value: "30" }, - }, - ast: "_-_(\n 42^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_-_(\n 42~int,\n 12~int\n)~int^subtract_int64", - type: "int", - }, - { - original: { - name: "sub_positive_negative", - expr: "42 - (-22)", - value: { int64Value: "64" }, - }, - ast: "_-_(\n 42^#*expr.Constant_Int64Value#,\n -22^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_-_(\n 42~int,\n -22~int\n)~int^subtract_int64", - type: "int", - }, - { - original: { - name: "sub_negative_negative", - expr: "-42 - (-12)", - value: { int64Value: "-30" }, - }, - ast: "_-_(\n -42^#*expr.Constant_Int64Value#,\n -12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_-_(\n -42~int,\n -12~int\n)~int^subtract_int64", - type: "int", - }, - { - original: { - name: "multiply_positive_positive", - expr: "42 * 2", - value: { int64Value: "84" }, - }, - ast: "_*_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_*_(\n 42~int,\n 2~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "multiply_positive_negative", - expr: "40 * (-2)", - value: { int64Value: "-80" }, - }, - ast: "_*_(\n 40^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_*_(\n 40~int,\n -2~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "multiply_negative_negative", - expr: "-30 * (-2)", - value: { int64Value: "60" }, - }, - ast: "_*_(\n -30^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_*_(\n -30~int,\n -2~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "divide_positive_positive", - expr: "42 / 2", - value: { int64Value: "21" }, - }, - ast: "_/_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n 42~int,\n 2~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "divide_positive_negative", - expr: "-20 / 2", - value: { int64Value: "-10" }, - }, - ast: "_/_(\n -20^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n -20~int,\n 2~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "divide_negative_negative", - expr: "-80 / (-2)", - value: { int64Value: "40" }, - }, - ast: "_/_(\n -80^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n -80~int,\n -2~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "mod_positive_positive", - expr: "47 % 5", - value: { int64Value: "2" }, - }, - ast: "_%_(\n 47^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n 47~int,\n 5~int\n)~int^modulo_int64", - type: "int", - }, - { - original: { - name: "mod_positive_negative", - expr: "43 % (-5)", - value: { int64Value: "3" }, - }, - ast: "_%_(\n 43^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n 43~int,\n -5~int\n)~int^modulo_int64", - type: "int", - }, - { - original: { - name: "mod_negative_negative", - expr: "-42 % (-5)", - value: { int64Value: "-2" }, - }, - ast: "_%_(\n -42^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n -42~int,\n -5~int\n)~int^modulo_int64", - type: "int", - }, - { - original: { - name: "mod_negative_positive", - expr: "-3 % 5", - value: { int64Value: "-3" }, - }, - ast: "_%_(\n -3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n -3~int,\n 5~int\n)~int^modulo_int64", - type: "int", - }, - { - original: { - name: "unary_minus_pos", - expr: "-(42)", - value: { int64Value: "-42" }, - }, - ast: "-_(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n 42~int\n)~int^negate_int64", - type: "int", - }, - { - original: { - name: "unary_minus_neg", - expr: "-(-42)", - value: { int64Value: "42" }, - }, - ast: "-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n -42~int\n)~int^negate_int64", - type: "int", - }, - { - original: { - name: "unary_minus_no_overload", - expr: "-(42u)", - disableCheck: true, - evalError: { errors: [{ message: "no_such_overload" }] }, - }, - ast: "-_(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(42u)\n | ^", - }, - { - original: { - name: "unary_minus_not_bool", - expr: "-false", - disableCheck: true, - evalError: { errors: [{ message: "no_such_overload" }] }, - }, - ast: "-_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(bool)'\n | -false\n | ^", - }, - { - original: { - name: "mod_zero", - expr: "34 % 0", - evalError: { errors: [{ message: "modulus by zero" }] }, - }, - ast: "_%_(\n 34^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n 34~int,\n 0~int\n)~int^modulo_int64", - type: "int", - }, - { - original: { - name: "negative_zero", - expr: "-(0)", - value: { int64Value: "0" }, - }, - ast: "-_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n 0~int\n)~int^negate_int64", - type: "int", - }, - { - original: { - name: "double_negative", - expr: "-(-42)", - value: { int64Value: "42" }, - }, - ast: "-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n -42~int\n)~int^negate_int64", - type: "int", - }, - { - original: { - name: "divide_zero", - expr: "15 / 0", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "_/_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n 15~int,\n 0~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "multiply_zero", - expr: "15 * 0", - value: { int64Value: "0" }, - }, - ast: "_*_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_*_(\n 15~int,\n 0~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "add_left_identity", - expr: "0 + 17", - value: { int64Value: "17" }, - }, - ast: "_+_(\n 0^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 0~int,\n 17~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "add_right_identity", - expr: " 29 + 0", - value: { int64Value: "29" }, - }, - ast: "_+_(\n 29^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 29~int,\n 0~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "add_commutative", - expr: "75 + 15 == 15 + 75", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n 75^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n 75~int,\n 15~int\n )~int^add_int64,\n _+_(\n 15~int,\n 75~int\n )~int^add_int64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "add_associative", - expr: "5 + (15 + 20) == (5 + 15) + 20", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n 5~int,\n _+_(\n 15~int,\n 20~int\n )~int^add_int64\n )~int^add_int64,\n _+_(\n _+_(\n 5~int,\n 15~int\n )~int^add_int64,\n 20~int\n )~int^add_int64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "mul_left_identity", - expr: "1 * 45", - value: { int64Value: "45" }, - }, - ast: "_*_(\n 1^#*expr.Constant_Int64Value#,\n 45^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_*_(\n 1~int,\n 45~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "mul_right_identity", - expr: "-25 * 1", - value: { int64Value: "-25" }, - }, - ast: "_*_(\n -25^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_*_(\n -25~int,\n 1~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "mul_commutative", - expr: "15 * 25 == 25 * 15", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 15~int,\n 25~int\n )~int^multiply_int64,\n _*_(\n 25~int,\n 15~int\n )~int^multiply_int64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "mul_associative", - expr: "15 * (23 * 88) == (15 * 23) * 88", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n _*_(\n 23^#*expr.Constant_Int64Value#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 15~int,\n _*_(\n 23~int,\n 88~int\n )~int^multiply_int64\n )~int^multiply_int64,\n _*_(\n _*_(\n 15~int,\n 23~int\n )~int^multiply_int64,\n 88~int\n )~int^multiply_int64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "add_mul_distribute", - expr: "5 * (15 + 25) == 5 * 15 + 5 * 25", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 5~int,\n _+_(\n 15~int,\n 25~int\n )~int^add_int64\n )~int^multiply_int64,\n _+_(\n _*_(\n 5~int,\n 15~int\n )~int^multiply_int64,\n _*_(\n 5~int,\n 25~int\n )~int^multiply_int64\n )~int^add_int64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "int64_overflow_positive", - description: "LLONG_MAX plus one.", - expr: "9223372036854775807 + 1", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_+_(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n 9223372036854775807~int,\n 1~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "int64_overflow_negative", - description: "LLONG_MIN minus one.", - expr: "-9223372036854775808 - 1", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_-_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_-_(\n -9223372036854775808~int,\n 1~int\n)~int^subtract_int64", - type: "int", - }, - { - original: { - name: "int64_overflow_add_negative", - description: "negative overflow via addition", - expr: "-9223372036854775808 + (-1)", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_+_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n -9223372036854775808~int,\n -1~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "int64_overflow_sub_positive", - description: "positive overflow via subtraction", - expr: "1 - (-9223372036854775807)", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_-_(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_-_(\n 1~int,\n -9223372036854775807~int\n)~int^subtract_int64", - type: "int", - }, - { - original: { - name: "int64_min_negate", - description: "Negated LLONG_MIN is not representable.", - expr: "-(-9223372036854775808)", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "-_(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "-_(\n -9223372036854775808~int\n)~int^negate_int64", - type: "int", - }, - { - original: { - name: "int64_min_negate_mul", - description: "Negate LLONG_MIN via multiplication", - expr: "(-9223372036854775808) * -1", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_*_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n -9223372036854775808~int,\n -1~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "int64_min_negate_div", - description: "Negate LLONG_MIN via division.", - expr: "(-9223372036854775808)/-1", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_/_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n -9223372036854775808~int,\n -1~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "int64_overflow_mul_positive", - description: "Overflow via multiplication.", - expr: "5000000000 * 5000000000", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_*_(\n 5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 5000000000~int,\n 5000000000~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "int64_overflow_mul_negative", - description: "Overflow via multiplication.", - expr: "(-5000000000) * 5000000000", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_*_(\n -5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n -5000000000~int,\n 5000000000~int\n)~int^multiply_int64", - type: "int", - }, - { - original: { - name: "uint64_overflow_positive", - description: "ULLONG_MAX plus one.", - expr: "18446744073709551615u + 1u", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_+_(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^add_uint64", - type: "uint", - }, - { - original: { - name: "uint64_overflow_negative", - description: "zero minus one.", - expr: "0u - 1u", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_-_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_-_(\n 0u~uint,\n 1u~uint\n)~uint^subtract_uint64", - type: "uint", - }, - { - original: { - name: "uint64_overflow_mul_positive", - description: "Overflow via multiplication.", - expr: "5000000000u * 5000000000u", - evalError: { - errors: [{ message: "return error for overflow" }], - }, - }, - ast: "_*_(\n 5000000000u^#*expr.Constant_Uint64Value#,\n 5000000000u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 5000000000u~uint,\n 5000000000u~uint\n)~uint^multiply_uint64", - type: "uint", - }, - ], - }, - { - name: "uint64_math", - tests: [ - { - original: { - name: "add", - expr: "42u + 2u", - value: { uint64Value: "44" }, - }, - ast: "_+_(\n 42u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 42u~uint,\n 2u~uint\n)~uint^add_uint64", - type: "uint", - }, - { - original: { - name: "sub", - expr: "42u - 12u", - value: { uint64Value: "30" }, - }, - ast: "_-_(\n 42u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_-_(\n 42u~uint,\n 12u~uint\n)~uint^subtract_uint64", - type: "uint", - }, - { - original: { - name: "multiply", - expr: "40u * 2u", - value: { uint64Value: "80" }, - }, - ast: "_*_(\n 40u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 40u~uint,\n 2u~uint\n)~uint^multiply_uint64", - type: "uint", - }, - { - original: { - name: "divide", - expr: "60u / 2u", - value: { uint64Value: "30" }, - }, - ast: "_/_(\n 60u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n 60u~uint,\n 2u~uint\n)~uint^divide_uint64", - type: "uint", - }, - { - original: { - name: "mod", - expr: "42u % 5u", - value: { uint64Value: "2" }, - }, - ast: "_%_(\n 42u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n 42u~uint,\n 5u~uint\n)~uint^modulo_uint64", - type: "uint", - }, - { - original: { - name: "negative_no_overload", - expr: "-(5u)", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "-_(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(5u)\n | ^", - }, - { - original: { - name: "mod_zero", - expr: "34u % 0u", - evalError: { errors: [{ message: "modulus by zero" }] }, - }, - ast: "_%_(\n 34u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_%_(\n 34u~uint,\n 0u~uint\n)~uint^modulo_uint64", - type: "uint", - }, - { - original: { - name: "divide_zero", - expr: "15u / 0u", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "_/_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n 15u~uint,\n 0u~uint\n)~uint^divide_uint64", - type: "uint", - }, - { - original: { - name: "multiply_zero", - expr: "15u * 0u", - value: { uint64Value: "0" }, - }, - ast: "_*_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 15u~uint,\n 0u~uint\n)~uint^multiply_uint64", - type: "uint", - }, - { - original: { - name: "add_left_identity", - expr: "0u + 17u", - value: { uint64Value: "17" }, - }, - ast: "_+_(\n 0u^#*expr.Constant_Uint64Value#,\n 17u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 0u~uint,\n 17u~uint\n)~uint^add_uint64", - type: "uint", - }, - { - original: { - name: "add_right_identity", - expr: " 29u + 0u", - value: { uint64Value: "29" }, - }, - ast: "_+_(\n 29u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_+_(\n 29u~uint,\n 0u~uint\n)~uint^add_uint64", - type: "uint", - }, - { - original: { - name: "add_commutative", - expr: "75u + 15u == 15u + 75u", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n 75u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 75u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n 75u~uint,\n 15u~uint\n )~uint^add_uint64,\n _+_(\n 15u~uint,\n 75u~uint\n )~uint^add_uint64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "add_associative", - expr: "5u + (15u + 20u) == (5u + 15u) + 20u", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n 5u~uint,\n _+_(\n 15u~uint,\n 20u~uint\n )~uint^add_uint64\n )~uint^add_uint64,\n _+_(\n _+_(\n 5u~uint,\n 15u~uint\n )~uint^add_uint64,\n 20u~uint\n )~uint^add_uint64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "mul_left_identity", - expr: "1u * 45u", - value: { uint64Value: "45" }, - }, - ast: "_*_(\n 1u^#*expr.Constant_Uint64Value#,\n 45u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 1u~uint,\n 45u~uint\n)~uint^multiply_uint64", - type: "uint", - }, - { - original: { - name: "mul_right_identity", - expr: "25u * 1u", - value: { uint64Value: "25" }, - }, - ast: "_*_(\n 25u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_*_(\n 25u~uint,\n 1u~uint\n)~uint^multiply_uint64", - type: "uint", - }, - { - original: { - name: "mul_commutative", - expr: "15u * 25u == 25u * 15u", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 15u~uint,\n 25u~uint\n )~uint^multiply_uint64,\n _*_(\n 25u~uint,\n 15u~uint\n )~uint^multiply_uint64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "mul_associative", - expr: "15u * (23u * 88u) == (15u * 23u) * 88u", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n _*_(\n 23u^#*expr.Constant_Uint64Value#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 23u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 15u~uint,\n _*_(\n 23u~uint,\n 88u~uint\n )~uint^multiply_uint64\n )~uint^multiply_uint64,\n _*_(\n _*_(\n 15u~uint,\n 23u~uint\n )~uint^multiply_uint64,\n 88u~uint\n )~uint^multiply_uint64\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "add_mul_distribute", - expr: "5u * (15u + 25u) == 5u * 15u + 5u * 25u", - value: { boolValue: true }, - }, - ast: "_==_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _*_(\n 5u~uint,\n _+_(\n 15u~uint,\n 25u~uint\n )~uint^add_uint64\n )~uint^multiply_uint64,\n _+_(\n _*_(\n 5u~uint,\n 15u~uint\n )~uint^multiply_uint64,\n _*_(\n 5u~uint,\n 25u~uint\n )~uint^multiply_uint64\n )~uint^add_uint64\n)~bool^equals", - type: "bool", - }, - ], - }, - ], - }, - { - name: "lists", - suites: [ - { - name: "concatenation", - tests: [ - { - original: { - name: "list_append", - expr: "[0, 1, 2] + [3, 4, 5] == [0, 1, 2, 3, 4, 5]", - value: { boolValue: true }, - }, - ast: "_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "list_not_commutative", - expr: "[0, 1, 2] + [3, 4, 5] == [3, 4, 5, 0, 1, 2]", - value: { boolValue: false }, - }, - ast: "_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 3~int,\n 4~int,\n 5~int,\n 0~int,\n 1~int,\n 2~int\n ]~list(int)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "list_repeat", - expr: "[2] + [2]", - value: { - listValue: { - values: [{ int64Value: "2" }, { int64Value: "2" }], - }, - }, - }, - ast: "_+_(\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n [\n 2~int\n ]~list(int),\n [\n 2~int\n ]~list(int)\n)~list(int)^add_list", - type: "list(int)", - }, - { - original: { - name: "empty_empty", - expr: "[] + []", - value: { listValue: {} }, - }, - ast: "_+_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n []~list(dyn),\n []~list(dyn)\n)~list(dyn)^add_list", - type: "list(dyn)", - }, - { - original: { - name: "left_unit", - expr: "[] + [3, 4]", - value: { - listValue: { - values: [{ int64Value: "3" }, { int64Value: "4" }], - }, - }, - }, - ast: "_+_(\n []^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n []~list(int),\n [\n 3~int,\n 4~int\n ]~list(int)\n)~list(int)^add_list", - type: "list(int)", - }, - { - original: { - name: "right_unit", - expr: "[1, 2] + []", - value: { - listValue: { - values: [{ int64Value: "1" }, { int64Value: "2" }], - }, - }, - }, - ast: "_+_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n [\n 1~int,\n 2~int\n ]~list(int),\n []~list(int)\n)~list(int)^add_list", - type: "list(int)", - }, - ], - }, - { - name: "index", - tests: [ - { - original: { - name: "zero_based", - expr: "[7, 8, 9][0]", - value: { int64Value: "7" }, - }, - ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n 0~int\n)~int^index_list", - type: "int", - }, - { - original: { - name: "zero_based_double", - expr: "[7, 8, 9][dyn(0.0)]", - value: { int64Value: "7" }, - }, - ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0~double\n )~dyn^to_dyn\n)~int^index_list", - type: "int", - }, - { - original: { - name: "zero_based_double_error", - expr: "[7, 8, 9][dyn(0.1)]", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0.1~double\n )~dyn^to_dyn\n)~int^index_list", - type: "int", - }, - { - original: { - name: "zero_based_uint", - expr: "[7, 8, 9][dyn(0u)]", - value: { int64Value: "7" }, - }, - ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0u~uint\n )~dyn^to_dyn\n)~int^index_list", - type: "int", - }, - { - original: { - name: "singleton", - expr: "['foo'][0]", - value: { stringValue: "foo" }, - }, - ast: '_[_](\n [\n "foo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n [\n "foo"~string\n ]~list(string),\n 0~int\n)~string^index_list', - type: "string", - }, - { - original: { - name: "middle", - expr: "[0, 1, 1, 2, 3, 5, 8, 13][4]", - value: { int64Value: "3" }, - }, - ast: "_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 0~int,\n 1~int,\n 1~int,\n 2~int,\n 3~int,\n 5~int,\n 8~int,\n 13~int\n ]~list(int),\n 4~int\n)~int^index_list", - type: "int", - }, - { - original: { - name: "last", - expr: "['George', 'John', 'Paul', 'Ringo'][3]", - value: { stringValue: "Ringo" }, - }, - ast: '_[_](\n [\n "George"^#*expr.Constant_StringValue#,\n "John"^#*expr.Constant_StringValue#,\n "Paul"^#*expr.Constant_StringValue#,\n "Ringo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n [\n "George"~string,\n "John"~string,\n "Paul"~string,\n "Ringo"~string\n ]~list(string),\n 3~int\n)~string^index_list', - type: "string", - }, - { - original: { - name: "index_out_of_bounds", - expr: "[1, 2, 3][3]", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: "_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n)~int^index_list", - type: "int", - }, - { - original: { - name: "index_out_of_bounds_or_false", - expr: "dyn([1, 2, 3][3]) || false", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: "_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "index_out_of_bounds_or_true", - expr: "dyn([1, 2, 3][3]) || true", - value: { boolValue: true }, - }, - ast: "_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "index_out_of_bounds_and_false", - expr: "dyn([1, 2, 3][3]) \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "index_out_of_bounds_and_true", - expr: "dyn([1, 2, 3][3]) \u0026\u0026 true", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "bad_index_type", - expr: "[1, 2, 3][dyn('')]", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: '_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n)~int^index_list', - type: "int", - }, - { - original: { - name: "bad_index_type_or_false", - expr: "dyn([1, 2, 3][dyn('')]) || false", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: '_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or', - type: "bool", - }, - { - original: { - name: "bad_index_type_or_true", - expr: "dyn([1, 2, 3][dyn('')]) || true", - value: { boolValue: true }, - }, - ast: '_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or', - type: "bool", - }, - { - original: { - name: "bad_index_type_and_false", - expr: "dyn([1, 2, 3][dyn('')]) \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and', - type: "bool", - }, - { - original: { - name: "bad_index_type_and_true", - expr: "dyn([1, 2, 3][dyn('')]) \u0026\u0026 true", - evalError: { errors: [{ message: "invalid_argument" }] }, - }, - ast: '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and', - type: "bool", - }, - ], - }, - { - name: "in", - tests: [ - { - original: { - name: "empty", - expr: "7 in []", - value: { boolValue: false }, - }, - ast: "@in(\n 7^#*expr.Constant_Int64Value#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: "@in(\n 7~int,\n []~list(int)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "singleton", - expr: "4u in [4u]", - value: { boolValue: true }, - }, - ast: "@in(\n 4u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n 4u~uint,\n [\n 4u~uint\n ]~list(uint)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "first", - expr: "'alpha' in ['alpha', 'beta', 'gamma']", - value: { boolValue: true }, - }, - ast: '@in(\n "alpha"^#*expr.Constant_StringValue#,\n [\n "alpha"^#*expr.Constant_StringValue#,\n "beta"^#*expr.Constant_StringValue#,\n "gamma"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "alpha"~string,\n [\n "alpha"~string,\n "beta"~string,\n "gamma"~string\n ]~list(string)\n)~bool^in_list', - type: "bool", - }, - { - original: { - name: "middle", - expr: "3 in [5, 4, 3, 2, 1]", - value: { boolValue: true }, - }, - ast: "@in(\n 3^#*expr.Constant_Int64Value#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n 3~int,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "last", - expr: "20u in [4u, 6u, 8u, 12u, 20u]", - value: { boolValue: true }, - }, - ast: "@in(\n 20u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#,\n 6u^#*expr.Constant_Uint64Value#,\n 8u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n 20u~uint,\n [\n 4u~uint,\n 6u~uint,\n 8u~uint,\n 12u~uint,\n 20u~uint\n ]~list(uint)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "double_in_ints", - expr: "dyn(3.0) in [5, 4, 3, 2, 1]", - value: { boolValue: true }, - }, - ast: "@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "uint_in_ints", - expr: "dyn(3u) in [5, 4, 3, 2, 1]", - value: { boolValue: true }, - }, - ast: "@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "int_in_doubles", - expr: "dyn(3) in [5.0, 4.0, 3.0, 2.0, 1.0]", - value: { boolValue: true }, - }, - ast: "@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "uint_in_doubles", - expr: "dyn(3u) in [5.0, 4.0, 3.0, 2.0, 1.0]", - value: { boolValue: true }, - }, - ast: "@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "int_in_uints", - expr: "dyn(3) in [5u, 4u, 3u, 2u, 1u]", - value: { boolValue: true }, - }, - ast: "@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "double_in_uints", - expr: "dyn(3.0) in [5u, 4u, 3u, 2u, 1u]", - value: { boolValue: true }, - }, - ast: "@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list", - type: "bool", - }, - { - original: { - name: "missing", - expr: "'hawaiian' in ['meat', 'veggie', 'margarita', 'cheese']", - value: { boolValue: false }, - }, - ast: '@in(\n "hawaiian"^#*expr.Constant_StringValue#,\n [\n "meat"^#*expr.Constant_StringValue#,\n "veggie"^#*expr.Constant_StringValue#,\n "margarita"^#*expr.Constant_StringValue#,\n "cheese"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '@in(\n "hawaiian"~string,\n [\n "meat"~string,\n "veggie"~string,\n "margarita"~string,\n "cheese"~string\n ]~list(string)\n)~bool^in_list', - type: "bool", - }, - ], - }, - { - name: "size", - tests: [ - { - original: { - name: "list_empty", - expr: "size([])", - value: { int64Value: "0" }, - }, - ast: "size(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: "size(\n []~list(dyn)\n)~int^size_list", - type: "int", - }, - { - original: { - name: "list", - expr: "size([1, 2, 3])", - value: { int64Value: "3" }, - }, - ast: "size(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "size(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~int^size_list", - type: "int", - }, - { - original: { - name: "map_empty", - expr: "size({})", - value: { int64Value: "0" }, - }, - ast: "size(\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: "size(\n {}~map(dyn, dyn)\n)~int^size_map", - type: "int", - }, - { - original: { - name: "map", - expr: "size({1: 'one', 2: 'two', 3: 'three'})", - value: { int64Value: "3" }, - }, - ast: 'size(\n {\n 1^#*expr.Constant_Int64Value#:"one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:"three"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'size(\n {\n 1~int:"one"~string,\n 2~int:"two"~string,\n 3~int:"three"~string\n }~map(int, string)\n)~int^size_map', - type: "int", - }, - ], - }, - ], - }, - { - name: "logic", - suites: [ - { - name: "conditional", - tests: [ - { - original: { - name: "true_case", - expr: "true ? 1 : 2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n true~bool,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - { - original: { - name: "false_case", - expr: "false ? 'foo' : 'bar'", - value: { stringValue: "bar" }, - }, - ast: '_?_:_(\n false^#*expr.Constant_BoolValue#,\n "foo"^#*expr.Constant_StringValue#,\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_?_:_(\n false~bool,\n "foo"~string,\n "bar"~string\n)~string^conditional', - type: "string", - }, - { - original: { - name: "error_case", - expr: "2 / 0 \u003e 4 ? 'baz' : 'quux'", - evalError: { errors: [{ message: "division by zero" }] }, - }, - ast: '_?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "baz"^#*expr.Constant_StringValue#,\n "quux"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n "baz"~string,\n "quux"~string\n)~string^conditional', - type: "string", - }, - { - original: { - name: "mixed_type", - expr: "true ? 'cows' : 17", - disableCheck: true, - value: { stringValue: "cows" }, - }, - ast: '_?_:_(\n true^#*expr.Constant_BoolValue#,\n "cows"^#*expr.Constant_StringValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:6: found no matching overload for '_?_:_' applied to '(bool, string, int)'\n | true ? 'cows' : 17\n | .....^", - }, - { - original: { - name: "bad_type", - expr: "'cows' ? false : 17", - disableCheck: true, - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: '_?_:_(\n "cows"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:8: found no matching overload for '_?_:_' applied to '(string, bool, int)'\n | 'cows' ? false : 17\n | .......^", - }, - ], - }, - { - name: "AND", - tests: [ - { - original: { - name: "all_true", - expr: "true \u0026\u0026 true", - value: { boolValue: true }, - }, - ast: "_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n true~bool,\n true~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "all_false", - expr: "false \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n false~bool,\n false~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "false_left", - expr: "false \u0026\u0026 true", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n false~bool,\n true~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "false_right", - expr: "true \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n true~bool,\n false~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "short_circuit_type_left", - expr: "false \u0026\u0026 32", - disableCheck: true, - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:10: expected type 'bool' but found 'int'\n | false \u0026\u0026 32\n | .........^", - }, - { - original: { - name: "short_circuit_type_right", - expr: "'horses' \u0026\u0026 false", - disableCheck: true, - value: { boolValue: false }, - }, - ast: '_\u0026\u0026_(\n "horses"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' \u0026\u0026 false\n | ^", - }, - { - original: { - name: "short_circuit_error_left", - expr: "false \u0026\u0026 (2 / 0 \u003e 3 ? false : true)", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n false~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "short_circuit_error_right", - expr: "(2 / 0 \u003e 3 ? false : true) \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n false~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "error_right", - expr: "true \u0026\u0026 1/0 != 0", - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: "_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n true~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "error_left", - expr: "1/0 != 0 \u0026\u0026 true", - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: "_\u0026\u0026_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n true~bool\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "no_overload", - expr: "'less filling' \u0026\u0026 'tastes great'", - disableCheck: true, - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: '_\u0026\u0026_(\n "less filling"^#*expr.Constant_StringValue#,\n "tastes great"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ..................^", - }, - ], - }, - { - name: "OR", - tests: [ - { - original: { - name: "all_true", - expr: "true || true", - value: { boolValue: true }, - }, - ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_||_(\n true~bool,\n true~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "all_false", - expr: "false || false", - value: { boolValue: false }, - }, - ast: "_||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n false~bool,\n false~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "false_left", - expr: "false || true", - value: { boolValue: true }, - }, - ast: "_||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n false~bool,\n true~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "false_right", - expr: "true || false", - value: { boolValue: true }, - }, - ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n true~bool,\n false~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "short_circuit_type_left", - expr: "true || 32", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:9: expected type 'bool' but found 'int'\n | true || 32\n | ........^", - }, - { - original: { - name: "short_circuit_type_right", - expr: "'horses' || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: '_||_(\n "horses"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' || true\n | ^", - }, - { - original: { - name: "short_circuit_error_left", - expr: "true || (2 / 0 \u003e 3 ? false : true)", - value: { boolValue: true }, - }, - ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n true~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "short_circuit_error_right", - expr: "(2 / 0 \u003e 3 ? false : true) || true", - value: { boolValue: true }, - }, - ast: "_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n true~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "error_right", - expr: "false || 1/0 != 0", - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: "_||_(\n false^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n false~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "error_left", - expr: "1/0 != 0 || false", - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: "_||_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n false~bool\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "no_overload", - expr: "'less filling' || 'tastes great'", - disableCheck: true, - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: '_||_(\n "less filling"^#*expr.Constant_StringValue#,\n "tastes great"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ..................^", - }, - ], - }, - { - name: "NOT", - tests: [ - { - original: { - name: "not_true", - expr: "!true", - value: { boolValue: false }, - }, - ast: "!_(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "!_(\n true~bool\n)~bool^logical_not", - type: "bool", - }, - { - original: { - name: "not_false", - expr: "!false", - value: { boolValue: true }, - }, - ast: "!_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "!_(\n false~bool\n)~bool^logical_not", - type: "bool", - }, - { - original: { - name: "no_overload", - expr: "!0", - disableCheck: true, - evalError: { errors: [{ message: "no matching overload" }] }, - }, - ast: "!_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: found no matching overload for '!_' applied to '(int)'\n | !0\n | ^", - }, - ], - }, - ], - }, - { - name: "macros", - suites: [ - { - name: "exists", - tests: [ - { - original: { - name: "list_elem_all_true", - expr: "[1, 2, 3].exists(e, e \u003e 0)", - value: { boolValue: true }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_some_true", - expr: "[1, 2, 3].exists(e, e == 2)", - value: { boolValue: true }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_none_true", - expr: "[1, 2, 3].exists(e, e \u003e 3)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_type_shortcircuit", - description: "Exists filter is true for the last element.", - expr: "[1, 'foo', 3].exists(e, e != '1')", - value: { boolValue: true }, - }, - ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n e^#*expr.Expr_IdentExpr#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n e~dyn^e,\n "1"~string\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - { - original: { - name: "list_elem_type_exhaustive", - description: - "Exists filter is never true, but heterogenous equality ensure the result is false.", - expr: "[1, 'foo', 3].exists(e, e == '10')", - value: { boolValue: false }, - }, - ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n "10"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n "10"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - { - original: { - name: "list_elem_exists_error", - expr: "[1, 2, 3].exists(e, e / 0 == 17)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_empty", - expr: "[].exists(e, e == 2)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "map_key", - expr: "{'key1':1, 'key2':2}.exists(k, k == 'key2')", - value: { boolValue: true }, - }, - ast: '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"~string:1~int,\n "key2"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n "key2"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - { - original: { - name: "not_map_key", - expr: "!{'key1':1, 'key2':2}.exists(k, k == 'key3')", - value: { boolValue: true }, - }, - ast: '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key3"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"~string:1~int,\n "key2"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n "key3"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not', - type: "bool", - }, - { - original: { - name: "map_key_type_shortcircuit", - description: "Exists filter is true for the second key", - expr: "{'key':1, 1:21}.exists(k, k != 2)", - value: { boolValue: true }, - }, - ast: '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key"~string:1~int,\n 1~int:21~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n k~dyn^k,\n 2~int\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - { - original: { - name: "map_key_type_exhaustive", - description: - "Exists filter is never true, but heterogeneous equality ensures the result is false.", - expr: "!{'key':1, 1:42}.exists(k, k == 2)", - value: { boolValue: true }, - }, - ast: '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key"~string:1~int,\n 1~int:42~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~dyn^k,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not', - type: "bool", - }, - ], - }, - { - name: "all", - tests: [ - { - original: { - name: "list_elem_all_true", - expr: "[1, 2, 3].all(e, e \u003e 0)", - value: { boolValue: true }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_some_true", - expr: "[1, 2, 3].all(e, e == 2)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_none_true", - expr: "[1, 2, 3].all(e, e == 17)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 17~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_type_shortcircuit", - expr: "[1, 'foo', 3].all(e, e == 1)", - value: { boolValue: false }, - }, - ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - { - original: { - name: "list_elem_type_exhaustive", - expr: "[1, 'foo', 3].all(e, e % 2 == 1)", - evalError: { errors: [{ message: "no_such_overload" }] }, - }, - ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _%_(\n e~dyn^e,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - { - original: { - name: "list_elem_error_shortcircuit", - expr: "[1, 2, 3].all(e, 6 / (2 - e) == 6)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n e^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _/_(\n 6~int,\n _-_(\n 2~int,\n e~int^e\n )~int^subtract_int64\n )~int^divide_int64,\n 6~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_elem_error_exhaustive", - expr: "[1, 2, 3].all(e, e / 0 != 17)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _!=_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^not_equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "list_empty", - expr: "[].all(e, e \u003e 0)", - value: { boolValue: true }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", - type: "bool", - }, - { - original: { - name: "map_key", - expr: "{'key1':1, 'key2':2}.all(k, k == 'key2')", - value: { boolValue: false }, - }, - ast: '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"~string:1~int,\n "key2"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n k~string^k,\n "key2"~string\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - ], - }, - { - name: "exists_one", - tests: [ - { - original: { - name: "list_empty", - expr: "[].exists_one(a, a == 7)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n a,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n a,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "list_one_true", - expr: "[7].exists_one(a, a == 7)", - value: { boolValue: true }, - }, - ast: "__comprehension__(\n // Variable\n a,\n // Target\n [\n 7^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n a,\n // Target\n [\n 7~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "list_one_false", - expr: "[8].exists_one(a, a == 7)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n a,\n // Target\n [\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n a,\n // Target\n [\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "list_none", - expr: "[1, 2, 3].exists_one(x, x \u003e 20)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n x,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n x^#*expr.Expr_IdentExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n x,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n x~int^x,\n 20~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "list_one", - expr: "[6, 7, 8].exists_one(foo, foo % 5 == 2)", - value: { boolValue: true }, - }, - ast: "__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6~int,\n 7~int,\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "list_many", - expr: "[0, 1, 2, 3, 4].exists_one(n, n % 2 == 1)", - value: { boolValue: false }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "list_all", - expr: "['foal', 'foo', 'four'].exists_one(n, n.startsWith('fo'))", - value: { boolValue: false }, - }, - ast: '__comprehension__(\n // Variable\n n,\n // Target\n [\n "foal"^#*expr.Constant_StringValue#,\n "foo"^#*expr.Constant_StringValue#,\n "four"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n n^#*expr.Expr_IdentExpr#.startsWith(\n "fo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n n,\n // Target\n [\n "foal"~string,\n "foo"~string,\n "four"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n n~string^n.startsWith(\n "fo"~string\n )~bool^starts_with_string,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool', - type: "bool", - }, - { - original: { - name: "list_no_shortcircuit", - description: - "Errors invalidate everything, even if already false.", - expr: "[3, 2, 1, 0].exists_one(n, 12 / n \u003e 1)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 1~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", - type: "bool", - }, - { - original: { - name: "map_one", - expr: "{6: 'six', 7: 'seven', 8: 'eight'}.exists_one(foo, foo % 5 == 2)", - value: { boolValue: true }, - }, - ast: '__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6^#*expr.Constant_Int64Value#:"six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:"seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:"eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6~int:"six"~string,\n 7~int:"seven"~string,\n 8~int:"eight"~string\n }~map(int, string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool', - type: "bool", - }, - ], - }, - { - name: "map", - tests: [ - { - original: { - name: "list_empty", - expr: "[].map(n, n / 2)", - value: { listValue: {} }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_one", - expr: "[3].map(n, n * n)", - value: { listValue: { values: [{ int64Value: "9" }] } }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _*_(\n n^#*expr.Expr_IdentExpr#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _*_(\n n~int^n,\n n~int^n\n )~int^multiply_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_many", - expr: "[2, 4, 6].map(n, n / 2)", - value: { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - { int64Value: "3" }, - ], - }, - }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 4~int,\n 6~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_error", - expr: "[2, 1, 0].map(n, 4 / n)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n 4^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n 4~int,\n n~int^n\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "map_extract_keys", - expr: "{'John': 'smart'}.map(key, key) == ['John']", - value: { boolValue: true }, - }, - ast: '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"^#*expr.Constant_StringValue#:"smart"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n "John"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"~string:"smart"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n // Result\n @result~list(string)^@result)~list(string),\n [\n "John"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "filter", - tests: [ - { - original: { - name: "list_empty", - expr: "[].filter(n, n % 2 == 0)", - value: { listValue: {} }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 0~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_one_true", - expr: "[2].filter(n, n == 2)", - value: { listValue: { values: [{ int64Value: "2" }] } }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n n~int^n,\n 2~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_one_false", - expr: "[1].filter(n, n \u003e 3)", - value: { listValue: {} }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_none", - expr: "[1, 2, 3].filter(e, e \u003e 3)", - value: { listValue: {} }, - }, - ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n e^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n e~int^e\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_some", - expr: "[0, 1, 2, 3, 4].filter(x, x % 2 == 1)", - value: { - listValue: { - values: [{ int64Value: "1" }, { int64Value: "3" }], - }, - }, - }, - ast: "__comprehension__(\n // Variable\n x,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n x,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x~int^x,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n x~int^x\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_all", - expr: "[1, 2, 3].filter(n, n \u003e 0)", - value: { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "2" }, - { int64Value: "3" }, - ], - }, - }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 0~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "list_no_shortcircuit", - expr: "[3, 2, 1, 0].filter(n, 12 / n \u003e 4)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "map_filter_keys", - expr: "{'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}.filter(key, key == 'Ringo') == ['Ringo']", - value: { boolValue: true }, - }, - ast: '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"^#*expr.Constant_StringValue#:"smart"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Paul"^#*expr.Constant_StringValue#:"cute"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "George"^#*expr.Constant_StringValue#:"quiet"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Ringo"^#*expr.Constant_StringValue#:"funny"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n key^#*expr.Expr_IdentExpr#,\n "Ringo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n "Ringo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"~string:"smart"~string,\n "Paul"~string:"cute"~string,\n "George"~string:"quiet"~string,\n "Ringo"~string:"funny"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n key~string^key,\n "Ringo"~string\n )~bool^equals,\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string),\n [\n "Ringo"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "nested", - tests: [ - { - original: { - name: "filter_all", - expr: "['signer'].filter(signer, ['artifact'].all(artifact, true))", - value: { listValue: { values: [{ stringValue: "signer" }] } }, - }, - ast: '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n signer^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool,\n _+_(\n @result~list(string)^@result,\n [\n signer~string^signer\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string)', - type: "list(string)", - }, - { - original: { - name: "all_all", - expr: "['signer'].all(signer, ['artifact'].all(artifact, true))", - value: { boolValue: true }, - }, - ast: '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', - checkedAst: - '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', - type: "bool", - }, - ], - }, - ], - }, - { - name: "macros2", - suites: [ - { - name: "exists", - tests: [ - { - original: { - name: "list_elem_all_true", - expr: "[1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)", - value: { boolValue: true }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................................^", - }, - { - original: { - name: "list_elem_some_true", - expr: "[1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)", - value: { boolValue: true }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................................^", - }, - { - original: { - name: "list_elem_none_true", - expr: "[1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)", - value: { boolValue: false }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................................^", - }, - { - original: { - name: "list_elem_type_shortcircuit", - expr: "[1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')", - value: { boolValue: true }, - }, - ast: '[\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................................^", - }, - { - original: { - name: "list_elem_type_exhaustive", - expr: "[1, 'foo', 3].exists(i, v, i == 3 || v == '10')", - value: { boolValue: false }, - }, - ast: '[\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "10"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................................^", - }, - { - original: { - name: "list_elem_exists_error", - expr: "[1, 2, 3].exists(i, v, v / i == 17)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ...........................^", - }, - { - original: { - name: "list_empty", - expr: "[].exists(i, v, i == 0 || v == 2)", - value: { boolValue: false }, - }, - ast: "[]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:10: undeclared reference to 'exists' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .........^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........................^", - }, - { - original: { - name: "map_key", - expr: "{'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)", - value: { boolValue: true }, - }, - ast: '{\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:28: undeclared reference to 'exists' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..................................^\nERROR: \u003cinput\u003e:1:50: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .................................................^", - }, - { - original: { - name: "not_map_key", - expr: "!{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)", - value: { boolValue: true }, - }, - ast: '!_(\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key3"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:29: undeclared reference to 'exists' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ............................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ................................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ...................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ..................................................^", - }, - { - original: { - name: "map_key_type_shortcircuit", - expr: "{'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)", - value: { boolValue: true }, - }, - ast: '{\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:23: undeclared reference to 'exists' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .............................^\nERROR: \u003cinput\u003e:1:40: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................................^", - }, - { - original: { - name: "map_key_type_exhaustive", - expr: "!{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)", - value: { boolValue: true }, - }, - ast: '!_(\n {\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 43^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'exists' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................................^", - }, - ], - }, - { - name: "all", - tests: [ - { - original: { - name: "list_elem_all_true", - expr: "[1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)", - value: { boolValue: true }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............................^", - }, - { - original: { - name: "list_elem_some_true", - expr: "[1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)", - value: { boolValue: false }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............................^", - }, - { - original: { - name: "list_elem_none_true", - expr: "[1, 2, 3].all(i, v, i == 3 || v == 4)", - value: { boolValue: false }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............................^", - }, - { - original: { - name: "list_elem_type_shortcircuit", - expr: "[1, 'foo', 3].all(i, v, i == 0 || v == 1)", - value: { boolValue: false }, - }, - ast: '[\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................................^", - }, - { - original: { - name: "list_elem_type_exhaustive", - expr: "[0, 'foo', 3].all(i, v, v % 2 == i)", - value: { boolValue: false }, - }, - ast: '[\n 0^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................................^", - }, - { - original: { - name: "list_elem_type_error_exhaustive", - expr: "[0, 'foo', 5].all(i, v, v % 3 == i)", - evalError: { errors: [{ message: "no_such_overload" }] }, - }, - ast: '[\n 0^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................................^", - }, - { - original: { - name: "list_elem_error_shortcircuit", - expr: "[1, 2, 3].all(i, v, 6 / (2 - v) == i)", - value: { boolValue: false }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ...................................^", - }, - { - original: { - name: "list_elem_error_exhaustive", - expr: "[1, 2, 3].all(i, v, v / i != 17)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ........................^", - }, - { - original: { - name: "list_empty", - expr: "[].all(i, v, i \u003e -1 || v \u003e 0)", - value: { boolValue: true }, - }, - ast: "[]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:7: undeclared reference to 'all' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ......^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......................^", - }, - { - original: { - name: "map_key", - expr: "{'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)", - value: { boolValue: false }, - }, - ast: '{\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.all(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:25: undeclared reference to 'all' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ........................^\nERROR: \u003cinput\u003e:1:26: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..............................................^", - }, - ], - }, - { - name: "existsOne", - tests: [ - { - original: { - name: "list_empty", - expr: "[].existsOne(i, v, i == 3 || v == 7)", - value: { boolValue: false }, - }, - ast: "[]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:13: undeclared reference to 'existsOne' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ............^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ...................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............................^", - }, - { - original: { - name: "list_one_true", - expr: "[7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)", - value: { boolValue: true }, - }, - ast: "[\n 7^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^", - }, - { - original: { - name: "list_one_false", - expr: "[8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)", - value: { boolValue: false }, - }, - ast: "[\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^", - }, - { - original: { - name: "list_none", - expr: "[1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)", - value: { boolValue: false }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................................^", - }, - { - original: { - name: "list_one", - expr: "[5, 7, 8].existsOne(i, v, v % 5 == i)", - value: { boolValue: true }, - }, - ast: "[\n 5^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................................^", - }, - { - original: { - name: "list_many", - expr: "[0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)", - value: { boolValue: false }, - }, - ast: "[\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:26: undeclared reference to 'existsOne' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................................^", - }, - { - original: { - name: "list_all", - expr: "['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))", - value: { boolValue: false }, - }, - ast: '[\n "foal"^#*expr.Constant_StringValue#,\n "foo"^#*expr.Constant_StringValue#,\n "four"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#.startsWith(\n "fo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:34: undeclared reference to 'existsOne' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .................................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .....................................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ........................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................................^", - }, - { - original: { - name: "list_no_shortcircuit", - expr: "[3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "[\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:23: undeclared reference to 'existsOne' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .............................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .................................^", - }, - { - original: { - name: "map_one", - expr: "{6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')", - value: { boolValue: true }, - }, - ast: '{\n 6^#*expr.Constant_Int64Value#:"six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:"seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:"eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.existsOne(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n _%_(\n k^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "seven"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:45: undeclared reference to 'existsOne' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ............................................^\nERROR: \u003cinput\u003e:1:46: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .............................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ................................................^\nERROR: \u003cinput\u003e:1:52: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ...................................................^\nERROR: \u003cinput\u003e:1:66: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .................................................................^", - }, - ], - }, - { - name: "transformList", - tests: [ - { - original: { - name: "empty", - expr: "[].transformList(i, v, i / v)", - value: { listValue: {} }, - }, - ast: "[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ...........................^", - }, - { - original: { - name: "empty_filter", - expr: "[].transformList(i, v, i \u003e v, i / v)", - value: { listValue: {} }, - }, - ast: "[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..................................^", - }, - { - original: { - name: "one", - expr: "[3].transformList(i, v, v * v + i)", - value: { listValue: { values: [{ int64Value: "9" }] } }, - }, - ast: "[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ................................^", - }, - { - original: { - name: "one_filter", - expr: "[3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)", - value: { listValue: { values: [{ int64Value: "9" }] } }, - }, - ast: "[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................^\nERROR: \u003cinput\u003e:1:43: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..........................................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................................^", - }, - { - original: { - name: "many", - expr: "[2, 4, 6].transformList(i, v, v / 2 + i)", - value: { - listValue: { - values: [ - { int64Value: "1" }, - { int64Value: "3" }, - { int64Value: "5" }, - ], - }, - }, - }, - ast: "[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ......................................^", - }, - { - original: { - name: "many_filter", - expr: "[2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)", - value: { - listValue: { - values: [{ int64Value: "1" }, { int64Value: "5" }], - }, - }, - }, - ast: "[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ................................................^\nERROR: \u003cinput\u003e:1:57: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................................^", - }, - { - original: { - name: "error", - expr: "[2, 1, 0].transformList(i, v, v / i)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..................................^", - }, - { - original: { - name: "error_filter", - expr: "[2, 1, 0].transformList(i, v, v / i \u003e 0, v)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: "[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .........................................^", - }, - ], - }, - { - name: "transformMap", - tests: [ - { - original: { - name: "empty", - expr: "{}.transformMap(k, v, k + v)", - value: { mapValue: {} }, - }, - ast: "{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ..........................^", - }, - { - original: { - name: "empty_filter", - expr: "{}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)", - value: { mapValue: {} }, - }, - ast: '{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "foo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "bar"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:37: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:53: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................................^", - }, - { - original: { - name: "one", - expr: "{'foo': 'bar'}.transformMap(k, v, k + v)", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "foo" }, - value: { stringValue: "foobar" }, - }, - ], - }, - }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ......................................^", - }, - { - original: { - name: "one_filter", - expr: "{'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "foo" }, - value: { stringValue: "foobar" }, - }, - ], - }, - }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "foo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "bar"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:65: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................................^", - }, - { - original: { - name: "many", - expr: "{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "foo" }, - value: { stringValue: "foobar" }, - }, - { - key: { stringValue: "baz" }, - value: { stringValue: "bazbux" }, - }, - { - key: { stringValue: "hello" }, - value: { stringValue: "helloworld" }, - }, - ], - }, - }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:"bux"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "hello"^#*expr.Constant_StringValue#:"world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:71: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ......................................................................^", - }, - { - original: { - name: "many_filter", - expr: "{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "foo" }, - value: { stringValue: "foobar" }, - }, - { - key: { stringValue: "hello" }, - value: { stringValue: "helloworld" }, - }, - ], - }, - }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:"bux"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "hello"^#*expr.Constant_StringValue#:"world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n "baz"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n "bux"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:81: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................^\nERROR: \u003cinput\u003e:1:93: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................................................^\nERROR: \u003cinput\u003e:1:97: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................................^", - }, - { - original: { - name: "error", - expr: "{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "bar"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:55: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ......................................................^", - }, - { - original: { - name: "error_filter", - expr: "{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)", - evalError: { errors: [{ message: "divide by zero" }] }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "bar"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "baz"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ..................................................^\nERROR: \u003cinput\u003e:1:69: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ....................................................................^\nERROR: \u003cinput\u003e:1:77: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................................................^", - }, - ], - }, - ], - }, - { - name: "math_ext", - suites: [ - { - name: "greatest_int_result", - tests: [ - { - original: { - name: "unary_negative", - expr: "math.greatest(-5)", - value: { int64Value: "-5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@max(\n -5~int\n)~int^math_@max_int", - type: "int", - }, - { - original: { - name: "unary_positive", - expr: "math.greatest(5)", - value: { int64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@max(\n 5~int\n)~int^math_@max_int", - type: "int", - }, - { - original: { - name: "binary_same_args", - expr: "math.greatest(1, 1)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1~int,\n 1~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "binary_with_decimal", - expr: "math.greatest(1, 1.0) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n 1~int,\n 1~double\n )~dyn^math_@max_int_double,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_with_uint", - expr: "math.greatest(1, 1u) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n 1~int,\n 1u~uint\n )~dyn^math_@max_int_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_first_arg_greater", - expr: "math.greatest(3, -3)", - value: { int64Value: "3" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 3^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 3~int,\n -3~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "binary_second_arg_greater", - expr: "math.greatest(-7, 5)", - value: { int64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -7^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n -7~int,\n 5~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "binary_first_arg_int_max", - expr: "math.greatest(9223372036854775807, 1)", - value: { int64Value: "9223372036854775807" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 9223372036854775807~int,\n 1~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "binary_second_arg_int_max", - expr: "math.greatest(1, 9223372036854775807)", - value: { int64Value: "9223372036854775807" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1~int,\n 9223372036854775807~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "binary_first_arg_int_min", - expr: "math.greatest(-9223372036854775808, 1)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n -9223372036854775808~int,\n 1~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "binary_second_arg_int_min", - expr: "math.greatest(1, -9223372036854775808)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1~int,\n -9223372036854775808~int\n)~int^math_@max_int_int", - type: "int", - }, - { - original: { - name: "ternary_same_args", - expr: "math.greatest(1, 1, 1) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@max_list_int,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_decimal", - expr: "math.greatest(1, 1.0, 1.0) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_uint", - expr: "math.greatest(1, 1u, 1u) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_first_arg_greatest", - expr: "math.greatest(10, 1, 3) == 10", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 10~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_third_arg_greatest", - expr: "math.greatest(1, 3, 10) == 10", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~int,\n 3~int,\n 10~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_negatives", - expr: "math.greatest(-1, -2, -3) == -1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_int_max", - expr: "math.greatest(9223372036854775807, 1, 5) == 9223372036854775807", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@max_list_int,\n 9223372036854775807~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_int_min", - expr: "math.greatest(-9223372036854775807, -1, -5) == -1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775807^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n -9223372036854775807~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed", - expr: "math.greatest(5.4, 10, 3u, -5.0, 9223372036854775807) == 9223372036854775807", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 9223372036854775807~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_array", - expr: "math.greatest([5.4, 10, 3u, -5.0, 3.5]) == 10", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_dyn_array", - expr: "math.greatest([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "greatest_double_result", - tests: [ - { - original: { - name: "unary_negative", - expr: "math.greatest(-5.0)", - value: { doubleValue: -5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@max(\n -5~double\n)~double^math_@max_double", - type: "double", - }, - { - original: { - name: "unary_positive", - expr: "math.greatest(5.0)", - value: { doubleValue: 5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@max(\n 5~double\n)~double^math_@max_double", - type: "double", - }, - { - original: { - name: "binary_same_args", - expr: "math.greatest(1.0, 1.0)", - value: { doubleValue: 1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1~double,\n 1~double\n)~double^math_@max_double_double", - type: "double", - }, - { - original: { - name: "binary_with_int", - expr: "math.greatest(1.0, 1) == 1.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n 1~double,\n 1~int\n )~dyn^math_@max_double_int,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_with_uint", - expr: "math.greatest(1.0, 1u) == 1.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n 1~double,\n 1u~uint\n )~dyn^math_@max_double_uint,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_first_arg_greater", - expr: "math.greatest(5.0, -7.0)", - value: { doubleValue: 5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#,\n -7^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 5~double,\n -7~double\n)~double^math_@max_double_double", - type: "double", - }, - { - original: { - name: "binary_second_arg_greater", - expr: "math.greatest(-3.0, 3.0)", - value: { doubleValue: 3 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n -3~double,\n 3~double\n)~double^math_@max_double_double", - type: "double", - }, - { - original: { - name: "binary_first_arg_double_max", - expr: "math.greatest(1.797693e308, 1)", - value: { doubleValue: 1.797693e308 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1.797693e+308~double,\n 1~int\n)~dyn^math_@max_double_int", - type: "dyn", - }, - { - original: { - name: "binary_second_arg_double_max", - expr: "math.greatest(1, 1.797693e308)", - value: { doubleValue: 1.797693e308 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1~int,\n 1.797693e+308~double\n)~dyn^math_@max_int_double", - type: "dyn", - }, - { - original: { - name: "binary_first_arg_double_min", - expr: "math.greatest(-1.797693e308, 1.5)", - value: { doubleValue: 1.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@max_double_double", - type: "double", - }, - { - original: { - name: "binary_second_arg_double_min", - expr: "math.greatest(1.5, -1.797693e308)", - value: { doubleValue: 1.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@max_double_double", - type: "double", - }, - { - original: { - name: "ternary_same_args", - expr: "math.greatest(1.0, 1.0, 1.0) == 1.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~double,\n 1~double,\n 1~double\n ]~list(double)\n )~double^math_@max_list_double,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_int", - expr: "math.greatest(1.0, 1, 1) == 1.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_uint", - expr: "math.greatest(1.0, 1u, 1u) == 1.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_first_arg_greatest", - expr: "math.greatest(10.5, 1.5, 3.5) == 10.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 10.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_third_arg_greatest", - expr: "math.greatest(1.5, 3.5, 10.5) == 10.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1.5~double,\n 3.5~double,\n 10.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_negatives", - expr: "math.greatest(-1.5, -2.5, -3.5) == -1.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n -1.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_double_max", - expr: "math.greatest(1.797693e308, 1, 5) == 1.797693e308", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_double_min", - expr: "math.greatest(-1.797693e308, -1, -5) == -1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n -1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed", - expr: "math.greatest(5.4, 10, 3u, -5.0, 1.797693e308) == 1.797693e308", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_array", - expr: "math.greatest([5.4, 10.5, 3u, -5.0, 3.5]) == 10.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_dyn_array", - expr: "math.greatest([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "greatest_uint_result", - tests: [ - { - original: { - name: "unary", - expr: "math.greatest(5u)", - value: { uint64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@max(\n 5u~uint\n)~uint^math_@max_uint", - type: "uint", - }, - { - original: { - name: "binary_same_args", - expr: "math.greatest(1u, 1u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint", - type: "uint", - }, - { - original: { - name: "binary_with_decimal", - expr: "math.greatest(1u, 1.0) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n 1u~uint,\n 1~double\n )~dyn^math_@max_uint_double,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_with_int", - expr: "math.greatest(1u, 1) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n 1u~uint,\n 1~int\n )~dyn^math_@max_uint_int,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_first_arg_greater", - expr: "math.greatest(5u, -7)", - value: { uint64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 5u~uint,\n -7~int\n)~dyn^math_@max_uint_int", - type: "dyn", - }, - { - original: { - name: "binary_second_arg_greater", - expr: "math.greatest(-3, 3u)", - value: { uint64Value: "3" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n -3~int,\n 3u~uint\n)~dyn^math_@max_int_uint", - type: "dyn", - }, - { - original: { - name: "binary_first_arg_uint_max", - expr: "math.greatest(18446744073709551615u, 1u)", - value: { uint64Value: "18446744073709551615" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint", - type: "uint", - }, - { - original: { - name: "binary_second_arg_uint_max", - expr: "math.greatest(1u, 18446744073709551615u)", - value: { uint64Value: "18446744073709551615" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@max(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@max_uint_uint", - type: "uint", - }, - { - original: { - name: "ternary_same_args", - expr: "math.greatest(1u, 1u, 1u) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_decimal", - expr: "math.greatest(1u, 1.0, 1.0) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_int", - expr: "math.greatest(1u, 1, 1) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_first_arg_greatest", - expr: "math.greatest(10u, 1u, 3u) == 10u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 10u~uint,\n 1u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_third_arg_greatest", - expr: "math.greatest(1u, 3u, 10u) == 10u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 1u~uint,\n 3u~uint,\n 10u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_int_max", - expr: "math.greatest(18446744073709551615u, 1u, 5u) == 18446744073709551615u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed", - expr: "math.greatest(5.4, 10, 3u, -5.0, 18446744073709551615u) == 18446744073709551615u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_array", - expr: "math.greatest([5.4, 10u, 3u, -5.0, 3.5]) == 10u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_dyn_array", - expr: "math.greatest([dyn(5.4), dyn(10u), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "least_int_result", - tests: [ - { - original: { - name: "unary_negative", - expr: "math.least(-5)", - value: { int64Value: "-5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@min(\n -5~int\n)~int^math_@min_int", - type: "int", - }, - { - original: { - name: "unary_positive", - expr: "math.least(5)", - value: { int64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@min(\n 5~int\n)~int^math_@min_int", - type: "int", - }, - { - original: { - name: "binary_same_args", - expr: "math.least(1, 1)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1~int,\n 1~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "binary_with_decimal", - expr: "math.least(1, 1.0) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n 1~int,\n 1~double\n )~dyn^math_@min_int_double,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_with_uint", - expr: "math.least(1, 1u) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_first_arg_least", - expr: "math.least(-3, 3)", - value: { int64Value: "-3" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n -3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n -3~int,\n 3~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "binary_second_arg_least", - expr: "math.least(5, -7)", - value: { int64Value: "-7" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 5~int,\n -7~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "binary_first_arg_int_max", - expr: "math.least(9223372036854775807, 1)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 9223372036854775807~int,\n 1~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "binary_second_arg_int_max", - expr: "math.least(1, 9223372036854775807)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1~int,\n 9223372036854775807~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "binary_first_arg_int_min", - expr: "math.least(-9223372036854775808, 1)", - value: { int64Value: "-9223372036854775808" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n -9223372036854775808~int,\n 1~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "binary_second_arg_int_min", - expr: "math.least(1, -9223372036854775808)", - value: { int64Value: "-9223372036854775808" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1~int,\n -9223372036854775808~int\n)~int^math_@min_int_int", - type: "int", - }, - { - original: { - name: "ternary_same_args", - expr: "math.least(1, 1, 1) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_decimal", - expr: "math.least(1, 1.0, 1.0) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_uint", - expr: "math.least(1, 1u, 1u) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_first_arg_least", - expr: "math.least(0, 1, 3) == 0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 0~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_third_arg_least", - expr: "math.least(1, 3, 0) == 0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1~int,\n 3~int,\n 0~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_negatives", - expr: "math.least(-1, -2, -3) == -3", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@min_list_int,\n -3~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_int_max", - expr: "math.least(9223372036854775807, 1, 5) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_int_min", - expr: "math.least(-9223372036854775808, -1, -5) == -9223372036854775808", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n -9223372036854775808~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@min_list_int,\n -9223372036854775808~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed", - expr: "math.least(5.4, 10, 3u, -5.0, 9223372036854775807) == -5.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_array", - expr: "math.least([5.4, 10, 3u, -5.0, 3.5]) == -5.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_dyn_array", - expr: "math.least([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "least_double_result", - tests: [ - { - original: { - name: "unary_negative", - expr: "math.least(-5.5)", - value: { doubleValue: -5.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n -5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n -5.5~double\n)~double^math_@min_double", - type: "double", - }, - { - original: { - name: "unary_positive", - expr: "math.least(5.5)", - value: { doubleValue: 5.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@min(\n 5.5~double\n)~double^math_@min_double", - type: "double", - }, - { - original: { - name: "binary_same_args", - expr: "math.least(1.5, 1.5)", - value: { doubleValue: 1.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1.5~double,\n 1.5~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "binary_with_int", - expr: "math.least(1.0, 1) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n 1~double,\n 1~int\n )~dyn^math_@min_double_int,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_with_uint", - expr: "math.least(1, 1u) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_first_arg_least", - expr: "math.least(-3.5, 3.5)", - value: { doubleValue: -3.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n -3.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n -3.5~double,\n 3.5~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "binary_second_arg_least", - expr: "math.least(5.5, -7.5)", - value: { doubleValue: -7.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#,\n -7.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 5.5~double,\n -7.5~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "binary_first_arg_double_max", - expr: "math.least(1.797693e308, 1.5)", - value: { doubleValue: 1.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "binary_second_arg_double_max", - expr: "math.least(1.5, 1.797693e308)", - value: { doubleValue: 1.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1.5~double,\n 1.797693e+308~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "binary_first_arg_double_min", - expr: "math.least(-1.797693e308, 1.5)", - value: { doubleValue: -1.797693e308 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "binary_second_arg_double_min", - expr: "math.least(1.5, -1.797693e308)", - value: { doubleValue: -1.797693e308 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@min_double_double", - type: "double", - }, - { - original: { - name: "ternary_same_args", - expr: "math.least(1.5, 1.5, 1.5) == 1.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1.5~double,\n 1.5~double,\n 1.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 1.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_int", - expr: "math.least(1.0, 1, 1) == 1.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_uint", - expr: "math.least(1.0, 1u, 1u) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_first_arg_least", - expr: "math.least(0.5, 1.5, 3.5) == 0.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 0.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_third_arg_least", - expr: "math.least(1.5, 3.5, 0.5) == 0.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 0.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1.5~double,\n 3.5~double,\n 0.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_negatives", - expr: "math.least(-1.5, -2.5, -3.5) == -3.5", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n -3.5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_double_max", - expr: "math.least(1.797693e308, 1, 5) == 1", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_double_min", - expr: "math.least(-1.797693e308, -1, -5) == -1.797693e308", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -1.797693e+308~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed", - expr: "math.least(5.4, 10, 3u, -5.0, 1.797693e308) == -5.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_array", - expr: "math.least([5.4, 10.5, 3u, -5.0, 3.5]) == -5.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_dyn_array", - expr: "math.least([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "least_uint_result", - tests: [ - { - original: { - name: "unary", - expr: "math.least(5u)", - value: { uint64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.@min(\n 5u~uint\n)~uint^math_@min_uint", - type: "uint", - }, - { - original: { - name: "binary_same_args", - expr: "math.least(1u, 1u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint", - type: "uint", - }, - { - original: { - name: "binary_with_decimal", - expr: "math.least(1u, 1.0) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n 1u~uint,\n 1~double\n )~dyn^math_@min_uint_double,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_with_int", - expr: "math.least(1u, 1) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n 1u~uint,\n 1~int\n )~dyn^math_@min_uint_int,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "binary_first_arg_least", - expr: "math.least(1u, 3u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1u~uint,\n 3u~uint\n)~uint^math_@min_uint_uint", - type: "uint", - }, - { - original: { - name: "binary_second_arg_least", - expr: "math.least(5u, 2u)", - value: { uint64Value: "2" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 5u~uint,\n 2u~uint\n)~uint^math_@min_uint_uint", - type: "uint", - }, - { - original: { - name: "binary_first_arg_uint_max", - expr: "math.least(18446744073709551615u, 1u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint", - type: "uint", - }, - { - original: { - name: "binary_second_arg_uint_max", - expr: "math.least(1u, 18446744073709551615u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.@min(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@min_uint_uint", - type: "uint", - }, - { - original: { - name: "ternary_same_args", - expr: "math.least(1u, 1u, 1u) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_decimal", - expr: "math.least(1u, 1.0, 1.0) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_with_int", - expr: "math.least(1u, 1, 1) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_first_arg_least", - expr: "math.least(1u, 10u, 3u) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 1u~uint,\n 10u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_third_arg_least", - expr: "math.least(10u, 3u, 1u) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 10u~uint,\n 3u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_uint_max", - expr: "math.least(18446744073709551615u, 1u, 5u) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed", - expr: "math.least(5.4, 10, 3u, 1u, 18446744073709551615u) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n 1u~uint,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_array", - expr: "math.least([5.4, 10u, 3u, 1u, 3.5]) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n 1u~uint,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "quaternary_mixed_dyn_array", - expr: "math.least([dyn(5.4), dyn(10u), dyn(3u), dyn(1u), dyn(3.5)]) == 1u", - }, - ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "ceil", - tests: [ - { - original: { - name: "negative", - expr: "math.ceil(-1.2)", - value: { doubleValue: -1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.ceil(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.ceil(\n -1.2~double\n)~double^math_ceil_double", - type: "double", - }, - { - original: { - name: "positive", - expr: "math.ceil(1.2)", - value: { doubleValue: 2 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.ceil(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.ceil(\n 1.2~double\n)~double^math_ceil_double", - type: "double", - }, - { - original: { - name: "dyn_error", - expr: "math.ceil(dyn(1))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.ceil(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.ceil(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_ceil_double", - type: "double", - }, - ], - }, - { - name: "floor", - tests: [ - { - original: { - name: "negative", - expr: "math.floor(-1.2)", - value: { doubleValue: -2 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.floor(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.floor(\n -1.2~double\n)~double^math_floor_double", - type: "double", - }, - { - original: { - name: "positive", - expr: "math.floor(1.2)", - value: { doubleValue: 1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.floor(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.floor(\n 1.2~double\n)~double^math_floor_double", - type: "double", - }, - { - original: { - name: "dyn_error", - expr: "math.floor(dyn(1))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.floor(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.floor(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_floor_double", - type: "double", - }, - ], - }, - { - name: "round", - tests: [ - { - original: { - name: "negative_down", - expr: "math.round(-1.6)", - value: { doubleValue: -2 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.round(\n -1.6^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.round(\n -1.6~double\n)~double^math_round_double", - type: "double", - }, - { - original: { - name: "negative_up", - expr: "math.round(-1.4)", - value: { doubleValue: -1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.round(\n -1.4^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.round(\n -1.4~double\n)~double^math_round_double", - type: "double", - }, - { - original: { - name: "negative_mid", - expr: "math.round(-1.5)", - value: { doubleValue: -2 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.round(\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.round(\n -1.5~double\n)~double^math_round_double", - type: "double", - }, - { - original: { - name: "positive_down", - expr: "math.round(1.2)", - value: { doubleValue: 1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.round(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.round(\n 1.2~double\n)~double^math_round_double", - type: "double", - }, - { - original: { - name: "positive_up", - expr: "math.round(1.5)", - value: { doubleValue: 2 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.round(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.round(\n 1.5~double\n)~double^math_round_double", - type: "double", - }, - { - original: { - name: "nan", - expr: "math.isNaN(math.round(0.0/0.0))", - }, - ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.round(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isNaN(\n math.round(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_round_double\n)~bool^math_isNaN_double", - type: "bool", - }, - { - original: { - name: "dyn_error", - expr: "math.round(dyn(1))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.round(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.round(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_round_double", - type: "double", - }, - ], - }, - { - name: "trunc", - tests: [ - { - original: { - name: "negative", - expr: "math.trunc(-1.2)", - value: { doubleValue: -1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.trunc(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.trunc(\n -1.2~double\n)~double^math_trunc_double", - type: "double", - }, - { - original: { - name: "positive", - expr: "math.trunc(1.2)", - value: { doubleValue: 1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.trunc(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.trunc(\n 1.2~double\n)~double^math_trunc_double", - type: "double", - }, - { - original: { - name: "nan", - expr: "math.isNaN(math.trunc(0.0/0.0))", - }, - ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.trunc(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isNaN(\n math.trunc(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_trunc_double\n)~bool^math_isNaN_double", - type: "bool", - }, - { - original: { - name: "dyn_error", - expr: "math.trunc(dyn(1))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.trunc(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.trunc(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_trunc_double", - type: "double", - }, - ], - }, - { - name: "abs", - tests: [ - { - original: { - name: "uint", - expr: "math.abs(1u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.abs(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.abs(\n 1u~uint\n)~uint^math_abs_uint", - type: "uint", - }, - { - original: { - name: "positive_int", - expr: "math.abs(1)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.abs(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.abs(\n 1~int\n)~int^math_abs_int", - type: "int", - }, - { - original: { - name: "negative_int", - expr: "math.abs(-11)", - value: { int64Value: "11" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.abs(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.abs(\n -11~int\n)~int^math_abs_int", - type: "int", - }, - { - original: { - name: "positive_double", - expr: "math.abs(1.5)", - value: { doubleValue: 1.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.abs(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.abs(\n 1.5~double\n)~double^math_abs_double", - type: "double", - }, - { - original: { - name: "negative_double", - expr: "math.abs(-11.5)", - value: { doubleValue: 11.5 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.abs(\n -11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.abs(\n -11.5~double\n)~double^math_abs_double", - type: "double", - }, - { - original: { - name: "int_overflow", - expr: "math.abs(-9223372036854775808)", - evalError: { errors: [{ message: "overflow" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.abs(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.abs(\n -9223372036854775808~int\n)~int^math_abs_int", - type: "int", - }, - ], - }, - { - name: "sign", - tests: [ - { - original: { - name: "positive_uint", - expr: "math.sign(100u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n 100u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n 100u~uint\n)~uint^math_sign_uint", - type: "uint", - }, - { - original: { - name: "zero_uint", - expr: "math.sign(0u)", - value: { uint64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n 0u~uint\n)~uint^math_sign_uint", - type: "uint", - }, - { - original: { - name: "positive_int", - expr: "math.sign(100)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n 100^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n 100~int\n)~int^math_sign_int", - type: "int", - }, - { - original: { - name: "negative_int", - expr: "math.sign(-11)", - value: { int64Value: "-1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n -11~int\n)~int^math_sign_int", - type: "int", - }, - { - original: { - name: "zero_int", - expr: "math.sign(0)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n 0~int\n)~int^math_sign_int", - type: "int", - }, - { - original: { - name: "positive_double", - expr: "math.sign(100.5)", - value: { doubleValue: 1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n 100.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.sign(\n 100.5~double\n)~double^math_sign_double", - type: "double", - }, - { - original: { - name: "negative_double", - expr: "math.sign(-32.0)", - value: { doubleValue: -1 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n -32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n -32~double\n)~double^math_sign_double", - type: "double", - }, - { - original: { - name: "zero_double", - expr: "math.sign(0.0)", - value: { doubleValue: 0 }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.sign(\n 0~double\n)~double^math_sign_double", - type: "double", - }, - { - original: { - name: "dyn_error", - expr: "math.sign(dyn(true))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.sign(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.sign(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~dyn^math_sign_double|math_sign_int|math_sign_uint", - type: "dyn", - }, - ], - }, - { - name: "isNaN", - tests: [ - { - original: { name: "true", expr: "math.isNaN(0.0/0.0)" }, - ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isNaN(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^math_isNaN_double", - type: "bool", - }, - { - original: { name: "false", expr: "!math.isNaN(1.0/0.0)" }, - ast: "!_(\n math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "!_(\n math.isNaN(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isNaN_double\n)~bool^logical_not", - type: "bool", - }, - { - original: { - name: "dyn_error", - expr: "math.isNaN(dyn(true))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isNaN(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isNaN_double", - type: "bool", - }, - ], - }, - { - name: "isInf", - tests: [ - { - original: { name: "true", expr: "math.isInf(1.0/0.0)" }, - ast: "math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isInf(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n)~bool^math_isInf_double", - type: "bool", - }, - { - original: { name: "false", expr: "!math.isInf(0.0/0.0)" }, - ast: "!_(\n math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "!_(\n math.isInf(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isInf_double\n)~bool^logical_not", - type: "bool", - }, - { - original: { - name: "dyn_error", - expr: "math.isInf(dyn(true))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.isInf(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isInf(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isInf_double", - type: "bool", - }, - ], - }, - { - name: "isFinite", - tests: [ - { - original: { name: "true", expr: "math.isFinite(1.0/1.5)" }, - ast: "math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isFinite(\n _/_(\n 1~double,\n 1.5~double\n )~double^divide_double\n)~bool^math_isFinite_double", - type: "bool", - }, - { - original: { name: "false_nan", expr: "!math.isFinite(0.0/0.0)" }, - ast: "!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "!_(\n math.isFinite(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not", - type: "bool", - }, - { - original: { name: "false_inf", expr: "!math.isFinite(-1.0/0.0)" }, - ast: "!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n -1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "!_(\n math.isFinite(\n _/_(\n -1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not", - type: "bool", - }, - { - original: { - name: "dyn_error", - expr: "math.isFinite(dyn(true))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.isFinite(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.isFinite(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isFinite_double", - type: "bool", - }, - ], - }, - { - name: "bit_and", - tests: [ - { - original: { - name: "int_int_non_intersect", - expr: "math.bitAnd(1, 2)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitAnd(\n 1~int,\n 2~int\n)~int^math_bitAnd_int_int", - type: "int", - }, - { - original: { - name: "int_int_intersect", - expr: "math.bitAnd(1, 3)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitAnd(\n 1~int,\n 3~int\n)~int^math_bitAnd_int_int", - type: "int", - }, - { - original: { - name: "int_int_intersect_neg", - expr: "math.bitAnd(1, -1)", - value: { int64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitAnd(\n 1~int,\n -1~int\n)~int^math_bitAnd_int_int", - type: "int", - }, - { - original: { - name: "uint_uint_non_intersect", - expr: "math.bitAnd(1u, 2u)", - value: { uint64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitAnd(\n 1u~uint,\n 2u~uint\n)~uint^math_bitAnd_uint_uint", - type: "uint", - }, - { - original: { - name: "uint_uint_intersect", - expr: "math.bitAnd(1u, 3u)", - value: { uint64Value: "1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitAnd(\n 1u~uint,\n 3u~uint\n)~uint^math_bitAnd_uint_uint", - type: "uint", - }, - { - original: { - name: "int_dyn_error", - expr: "math.bitAnd(2u, dyn(''))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: 'math^#*expr.Expr_IdentExpr#.bitAnd(\n 2u^#*expr.Constant_Uint64Value#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'math.bitAnd(\n 2u~uint,\n dyn(\n ""~string\n )~dyn^to_dyn\n)~uint^math_bitAnd_uint_uint', - type: "uint", - }, - ], - }, - { - name: "bit_or", - tests: [ - { - original: { - name: "int_int_positive", - expr: "math.bitOr(1, 2)", - value: { int64Value: "3" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitOr(\n 1~int,\n 2~int\n)~int^math_bitOr_int_int", - type: "int", - }, - { - original: { - name: "int_int_positive_negative", - expr: "math.bitOr(4, -2)", - value: { int64Value: "-2" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitOr(\n 4~int,\n -2~int\n)~int^math_bitOr_int_int", - type: "int", - }, - { - original: { - name: "uint_uint", - expr: "math.bitOr(1u, 4u)", - value: { uint64Value: "5" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n 1u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitOr(\n 1u~uint,\n 4u~uint\n)~uint^math_bitOr_uint_uint", - type: "uint", - }, - { - original: { - name: "dyn_int_error", - expr: "math.bitOr(dyn(1.2), 1)", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n dyn(\n 1.2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitOr(\n dyn(\n 1.2~double\n )~dyn^to_dyn,\n 1~int\n)~int^math_bitOr_int_int", - type: "int", - }, - ], - }, - { - name: "bit_xor", - tests: [ - { - original: { - name: "int_int_positive", - expr: "math.bitXor(1, 3)", - value: { int64Value: "2" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitXor(\n 1~int,\n 3~int\n)~int^math_bitXor_int_int", - type: "int", - }, - { - original: { - name: "int_int_positive_negative", - expr: "math.bitXor(4, -2)", - value: { int64Value: "-6" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitXor(\n 4~int,\n -2~int\n)~int^math_bitXor_int_int", - type: "int", - }, - { - original: { - name: "uint_uint", - expr: "math.bitXor(1u, 3u)", - value: { uint64Value: "2" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitXor(\n 1u~uint,\n 3u~uint\n)~uint^math_bitXor_uint_uint", - type: "uint", - }, - { - original: { - name: "dyn_dyn_error", - expr: "math.bitXor(dyn([]), dyn([1]))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitXor(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n dyn(\n [\n 1~int\n ]~list(int)\n )~dyn^to_dyn\n)~dyn^math_bitXor_int_int|math_bitXor_uint_uint", - type: "dyn", - }, - ], - }, - { - name: "bit_not", - tests: [ - { - original: { - name: "int_positive", - expr: "math.bitNot(1)", - value: { int64Value: "-2" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.bitNot(\n 1~int\n)~int^math_bitNot_int_int", - type: "int", - }, - { - original: { - name: "int_negative", - expr: "math.bitNot(-1)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.bitNot(\n -1~int\n)~int^math_bitNot_int_int", - type: "int", - }, - { - original: { - name: "int_zero", - expr: "math.bitNot(0)", - value: { int64Value: "-1" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "math.bitNot(\n 0~int\n)~int^math_bitNot_int_int", - type: "int", - }, - { - original: { - name: "uint_positive", - expr: "math.bitNot(1u)", - value: { uint64Value: "18446744073709551614" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitNot(\n 1u~uint\n)~uint^math_bitNot_uint_uint", - type: "uint", - }, - { - original: { - name: "uint_zero", - expr: "math.bitNot(0u)", - value: { uint64Value: "18446744073709551615" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitNot(\n 0u~uint\n)~uint^math_bitNot_uint_uint", - type: "uint", - }, - { - original: { - name: "dyn_error", - expr: "math.bitNot(dyn(''))", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: 'math^#*expr.Expr_IdentExpr#.bitNot(\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'math.bitNot(\n dyn(\n ""~string\n )~dyn^to_dyn\n)~dyn^math_bitNot_int_int|math_bitNot_uint_uint', - type: "dyn", - }, - ], - }, - { - name: "bit_shift_left", - tests: [ - { - original: { - name: "int", - expr: "math.bitShiftLeft(1, 2)", - value: { int64Value: "4" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n 1~int,\n 2~int\n)~int^math_bitShiftLeft_int_int", - type: "int", - }, - { - original: { - name: "int_large_shift", - expr: "math.bitShiftLeft(1, 200)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n 1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int", - type: "int", - }, - { - original: { - name: "int_negative_large_shift", - expr: "math.bitShiftLeft(-1, 200)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n -1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n -1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int", - type: "int", - }, - { - original: { - name: "uint", - expr: "math.bitShiftLeft(1u, 2)", - value: { uint64Value: "4" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n 1u~uint,\n 2~int\n)~uint^math_bitShiftLeft_uint_int", - type: "uint", - }, - { - original: { - name: "uint_large_shift", - expr: "math.bitShiftLeft(1u, 200)", - value: { uint64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n 1u~uint,\n 200~int\n)~uint^math_bitShiftLeft_uint_int", - type: "uint", - }, - { - original: { - name: "bad_shift", - expr: "math.bitShiftLeft(1u, -1)", - evalError: { errors: [{ message: "negative offset" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftLeft_uint_int", - type: "uint", - }, - { - original: { - name: "dyn_int_error", - expr: "math.bitShiftLeft(dyn(4.3), 1)", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n dyn(\n 4.3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftLeft(\n dyn(\n 4.3~double\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftLeft_int_int|math_bitShiftLeft_uint_int", - type: "dyn", - }, - ], - }, - { - name: "bit_shift_right", - tests: [ - { - original: { - name: "int", - expr: "math.bitShiftRight(1024, 2)", - value: { int64Value: "256" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n 1024~int,\n 2~int\n)~int^math_bitShiftRight_int_int", - type: "int", - }, - { - original: { - name: "int_large_shift", - expr: "math.bitShiftRight(1024, 64)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n 1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int", - type: "int", - }, - { - original: { - name: "int_negative", - expr: "math.bitShiftRight(-1024, 3)", - value: { int64Value: "2305843009213693824" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n -1024~int,\n 3~int\n)~int^math_bitShiftRight_int_int", - type: "int", - }, - { - original: { - name: "int_negative_large_shift", - expr: "math.bitShiftRight(-1024, 64)", - value: { int64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n -1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int", - type: "int", - }, - { - original: { - name: "uint", - expr: "math.bitShiftRight(1024u, 2)", - value: { uint64Value: "256" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n 1024u~uint,\n 2~int\n)~uint^math_bitShiftRight_uint_int", - type: "uint", - }, - { - original: { - name: "uint_large_shift", - expr: "math.bitShiftRight(1024u, 200)", - value: { uint64Value: "0" }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n 1024u~uint,\n 200~int\n)~uint^math_bitShiftRight_uint_int", - type: "uint", - }, - { - original: { - name: "bad_shift", - expr: "math.bitShiftRight(1u, -1)", - evalError: { errors: [{ message: "negative offset" }] }, - }, - ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "math.bitShiftRight(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftRight_uint_int", - type: "uint", - }, - { - original: { - name: "dyn_int_error", - expr: "math.bitShiftRight(dyn(b'123'), 1)", - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: 'math^#*expr.Expr_IdentExpr#.bitShiftRight(\n dyn(\n b"123"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'math.bitShiftRight(\n dyn(\n b"123"~bytes\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftRight_int_int|math_bitShiftRight_uint_int', - type: "dyn", - }, - ], - }, - ], - }, - { - name: "namespace", - suites: [ - { - name: "qualified", - tests: [ - { - original: { - name: "self_eval_qualified_lookup", - expr: "x.y", - typeEnv: [ - { name: "x.y", ident: { type: { primitive: "BOOL" } } }, - ], - bindings: { "x.y": { value: { boolValue: true } } }, - value: { boolValue: true }, - }, - ast: "x^#*expr.Expr_IdentExpr#.y^#*expr.Expr_SelectExpr#", - checkedAst: "x.y~bool^x.y", - type: "bool", - }, - ], - }, - { - name: "namespace", - tests: [ - { - original: { - name: "self_eval_container_lookup", - expr: "y", - typeEnv: [ - { name: "x.y", ident: { type: { primitive: "BOOL" } } }, - { name: "y", ident: { type: { primitive: "STRING" } } }, - ], - container: "x", - bindings: { - "x.y": { value: { boolValue: true } }, - y: { value: { stringValue: "false" } }, - }, - value: { boolValue: true }, - }, - ast: "y^#*expr.Expr_IdentExpr#", - checkedAst: "x.y~bool^x.y", - type: "bool", - }, - { - original: { - name: "self_eval_container_lookup_unchecked", - expr: "y", - disableCheck: true, - typeEnv: [ - { name: "x.y", ident: { type: { primitive: "BOOL" } } }, - { name: "y", ident: { type: { primitive: "BOOL" } } }, - ], - container: "x", - bindings: { - "x.y": { value: { boolValue: true } }, - y: { value: { boolValue: false } }, - }, - value: { boolValue: true }, - }, - ast: "y^#*expr.Expr_IdentExpr#", - checkedAst: "x.y~bool^x.y", - type: "bool", - }, - ], - }, - ], - }, - { - name: "optionals", - suites: [ - { - name: "optionals", - tests: [ - { - original: { - name: "null", - expr: "optional.of(null).hasValue()", - value: { boolValue: true }, - }, - ast: "optional^#*expr.Expr_IdentExpr#.of(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", - checkedAst: - "optional.of(\n null~null\n)~optional_type(null)^optional_of.hasValue()~bool^optional_hasValue", - type: "bool", - }, - { - original: { - name: "null_non_zero_value", - expr: "optional.ofNonZeroValue(null).hasValue()", - value: { boolValue: false }, - }, - ast: "optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", - checkedAst: - "optional.ofNonZeroValue(\n null~null\n)~optional_type(null)^optional_ofNonZeroValue.hasValue()~bool^optional_hasValue", - type: "bool", - }, - { - original: { - name: "none_or_none_or_value", - expr: "optional.none().or(optional.none()).orValue(42)", - value: { int64Value: "42" }, - }, - ast: "optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "optional.none()~optional_type(int)^optional_none.or(\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^optional_or_optional.orValue(\n 42~int\n)~int^optional_orValue_value", - type: "int", - }, - { - original: { - name: "none_optMap_hasValue", - expr: "optional.none().optMap(y, y + 1).hasValue()", - value: { boolValue: false }, - }, - ast: "optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n optional.none()~optional_type(dyn)^optional_none.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.none()~optional_type(int)^optional_none.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.hasValue()~bool^optional_hasValue", - type: "bool", - }, - { - original: { - name: "empty_map_optFlatMap_hasValue", - expr: "{}.?key.optFlatMap(k, k.?subkey).hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: empty_map_optFlatMap_hasValue:1:3: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ..^\nERROR: empty_map_optFlatMap_hasValue:1:24: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | .......................^", - }, - { - original: { - name: "map_empty_submap_optFlatMap_hasValue", - expr: "{'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: map_empty_submap_optFlatMap_hasValue:1:12: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ...........^\nERROR: map_empty_submap_optFlatMap_hasValue:1:33: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ................................^", - }, - { - original: { - name: "map_null_entry_hasValue", - expr: "{'null_key': dyn(null)}.?null_key.hasValue()", - value: { boolValue: true }, - }, - error: - "ERROR: map_null_entry_hasValue:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.hasValue()\n | .......................^", - }, - { - original: { - name: "map_null_entry_no_such_key", - expr: "{'null_key': dyn(null)}.?null_key.invalid.hasValue()", - evalError: { errors: [{ message: "no such key" }] }, - }, - error: - "ERROR: map_null_entry_no_such_key:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.invalid.hasValue()\n | .......................^", - }, - { - original: { - name: "map_absent_key_absent_field_none", - expr: "{true: dyn(0)}[?false].absent.hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: map_absent_key_absent_field_none:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?false].absent.hasValue()\n | ..............^", - }, - { - original: { - name: "map_present_key_invalid_field", - expr: "{true: dyn(0)}[?true].absent.hasValue()", - evalError: { errors: [{ message: "no such key" }] }, - }, - error: - "ERROR: map_present_key_invalid_field:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?true].absent.hasValue()\n | ..............^", - }, - { - original: { - name: "map_undefined_entry_hasValue", - expr: "{}.?null_key.invalid.hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: map_undefined_entry_hasValue:1:3: unsupported syntax '.?'\n | {}.?null_key.invalid.hasValue()\n | ..^", - }, - { - original: { - name: "map_submap_subkey_optFlatMap_value", - expr: "{'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()", - value: { stringValue: "subvalue" }, - }, - error: - "ERROR: map_submap_subkey_optFlatMap_value:1:32: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ...............................^\nERROR: map_submap_subkey_optFlatMap_value:1:53: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ....................................................^", - }, - { - original: { - name: "map_submap_optFlatMap_value", - expr: "{'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()", - value: { stringValue: "" }, - }, - error: - "ERROR: map_submap_optFlatMap_value:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | .......................^\nERROR: map_submap_optFlatMap_value:1:45: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | ............................................^", - }, - { - original: { - name: "map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue", - expr: "{'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()\n | .......................^", - }, - { - original: { - name: "optional_of_optMap_value", - expr: "optional.of(42).optMap(y, y + 1).value()", - value: { int64Value: "43" }, - }, - ast: "optional^#*expr.Expr_IdentExpr#.of(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.value()~int^optional_value", - type: "int", - }, - { - original: { - name: "optional_ofNonZeroValue_or_optional_value", - expr: "optional.ofNonZeroValue(42).or(optional.of(20)).value() == 42", - value: { boolValue: true }, - }, - ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n 42^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n optional.ofNonZeroValue(\n 42~int\n )~optional_type(int)^optional_ofNonZeroValue.or(\n optional.of(\n 20~int\n )~optional_type(int)^optional_of\n )~optional_type(int)^optional_or_optional.value()~int^optional_value,\n 42~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "ternary_optional_hasValue", - expr: "(has({}.x) ? optional.of({}.x) : optional.none()).hasValue()", - value: { boolValue: false }, - }, - ast: "_?_:_(\n {}^#*expr.Expr_StructExpr#.x~test-only~^#*expr.Expr_SelectExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n {}^#*expr.Expr_StructExpr#.x^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n {}~map(dyn, dyn).x~test-only~~bool,\n optional.of(\n {}~map(dyn, dyn).x~dyn\n )~optional_type(dyn)^optional_of,\n optional.none()~optional_type(dyn)^optional_none\n)~optional_type(dyn)^conditional.hasValue()~bool^optional_hasValue", - type: "bool", - }, - { - original: { - name: "map_optindex_hasValue", - expr: "{}.?x.hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: map_optindex_hasValue:1:3: unsupported syntax '.?'\n | {}.?x.hasValue()\n | ..^", - }, - { - original: { - name: "has_map_optindex", - expr: "has({}.?x.y)", - value: { boolValue: false }, - }, - error: - "ERROR: has_map_optindex:1:7: unsupported syntax '.?'\n | has({}.?x.y)\n | ......^", - }, - { - original: { - name: "has_map_optindex_field", - expr: "has({'x': {'y': 'z'}}.?x.y)", - value: { boolValue: true }, - }, - error: - "ERROR: has_map_optindex_field:1:22: unsupported syntax '.?'\n | has({'x': {'y': 'z'}}.?x.y)\n | .....................^", - }, - { - original: { - name: "type", - expr: "type(optional.none()) == optional_type", - value: { boolValue: true }, - }, - ast: "_==_(\n type(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional_type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n type(\n optional.none()~optional_type(dyn)^optional_none\n )~type(optional_type(dyn))^type,\n optional_type~type(optional_type)^optional_type\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "optional_chaining_1", - expr: "optional.ofNonZeroValue('').or(optional.of({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])).orValue('default value')", - value: { stringValue: "goodbye" }, - }, - ast: 'optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n _[_](\n {\n "c"^#*expr.Constant_StringValue#:{\n "dashed-index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n "dashed-index"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'optional.ofNonZeroValue(\n ""~string\n)~optional_type(string)^optional_ofNonZeroValue.or(\n optional.of(\n _[_](\n {\n "c"~string:{\n "dashed-index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n "dashed-index"~string\n )~string^index_map\n )~optional_type(string)^optional_of\n)~optional_type(string)^optional_or_optional.orValue(\n "default value"~string\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_2", - expr: "{'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')", - value: { stringValue: "goodbye" }, - }, - error: - "ERROR: optional_chaining_2:1:37: unsupported syntax '[?'\n | {'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')\n | ....................................^", - }, - { - original: { - name: "optional_chaining_3", - expr: "{'c': {}}.c[?'missing-index'].orValue('default value')", - value: { stringValue: "default value" }, - }, - error: - "ERROR: optional_chaining_3:1:12: unsupported syntax '[?'\n | {'c': {}}.c[?'missing-index'].orValue('default value')\n | ...........^", - }, - { - original: { - name: "optional_chaining_4", - expr: "optional.of({'c': {'index': 'goodbye'}}).c.index.orValue('default value')", - value: { stringValue: "goodbye" }, - }, - ast: 'optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.index^#*expr.Expr_SelectExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'optional.of(\n {\n "c"~string:{\n "index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string))\n)~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).index~optional_type(string).orValue(\n "default value"~string\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_5", - expr: "optional.of({'c': {}}).c.missing.or(optional.none()[0]).orValue('default value')", - value: { stringValue: "default value" }, - }, - ast: 'optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'optional.of(\n {\n "c"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.none()~optional_type(list(string))^optional_none,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n "default value"~string\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_6", - expr: "optional.of({'c': {}}).c.missing.or(optional.of(['list-value'])[0]).orValue('default value')", - value: { stringValue: "list-value" }, - }, - ast: 'optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.of(\n [\n "list-value"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'optional.of(\n {\n "c"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.of(\n [\n "list-value"~string\n ]~list(string)\n )~optional_type(list(string))^optional_of,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n "default value"~string\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_7", - expr: "optional.of({'c': {'index': 'goodbye'}}).c['index'].orValue('default value')", - value: { stringValue: "goodbye" }, - }, - ast: '_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n "index"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n optional.of(\n {\n "c"~string:{\n "index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n "index"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n "default value"~string\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_8", - expr: "optional.of({'c': {}}).c['missing'].orValue('default value')", - value: { stringValue: "default value" }, - }, - ast: '_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n "missing"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n optional.of(\n {\n "c"~string:{}~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n "missing"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n "default value"~string\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_9", - expr: "has(optional.of({'c': {'entry': 'hello world'}}).c) \u0026\u0026 !has(optional.of({'c': {'entry': 'hello world'}}).c.missing)", - value: { boolValue: true }, - }, - ast: '_\u0026\u0026_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "entry"^#*expr.Constant_StringValue#:"hello world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c~test-only~^#*expr.Expr_SelectExpr#,\n !_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "entry"^#*expr.Constant_StringValue#:"hello world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing~test-only~^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u0026\u0026_(\n optional.of(\n {\n "c"~string:{\n "entry"~string:"hello world"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~test-only~~bool,\n !_(\n optional.of(\n {\n "c"~string:{\n "entry"~string:"hello world"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).missing~test-only~~bool\n )~bool^logical_not\n)~bool^logical_and', - type: "bool", - }, - { - original: { - name: "optional_chaining_10", - expr: "optional.ofNonZeroValue({'c': {'dashed-index': 'goodbye'}}.a.z).orValue({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])", - evalError: { errors: [{ message: "no such key" }] }, - }, - ast: 'optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n {\n "c"^#*expr.Constant_StringValue#:{\n "dashed-index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.a^#*expr.Expr_SelectExpr#.z^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n _[_](\n {\n "c"^#*expr.Constant_StringValue#:{\n "dashed-index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n "dashed-index"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'optional.ofNonZeroValue(\n {\n "c"~string:{\n "dashed-index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string)).a~map(string, string).z~string\n)~optional_type(string)^optional_ofNonZeroValue.orValue(\n _[_](\n {\n "c"~string:{\n "dashed-index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n "dashed-index"~string\n )~string^index_map\n)~string^optional_orValue_value', - type: "string", - }, - { - original: { - name: "optional_chaining_11", - expr: "{'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()", - value: { int64Value: "7" }, - }, - error: - "ERROR: optional_chaining_11:1:35: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ..................................^\nERROR: optional_chaining_11:1:84: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ...................................................................................^", - }, - { - original: { - name: "optional_chaining_12", - expr: "{?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "nested_map" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "map" }, - value: { - mapValue: { - entries: [ - { - key: { stringValue: "dashed-index" }, - value: { stringValue: "goodbye" }, - }, - ], - }, - }, - }, - ], - }, - }, - }, - ], - }, - }, - }, - error: - "ERROR: optional_chaining_12:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}\n | .^", - }, - { - original: { - name: "optional_chaining_13", - expr: "{?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "singleton" }, - value: { boolValue: true }, - }, - ], - }, - }, - }, - error: - "ERROR: optional_chaining_13:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}\n | .^", - }, - { - original: { - name: "optional_chaining_14", - expr: "[?{}.?c, ?optional.of(42), ?optional.none()]", - value: { listValue: { values: [{ int64Value: "42" }] } }, - }, - error: - "ERROR: optional_chaining_14:1:2: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .^\nERROR: optional_chaining_14:1:5: unsupported syntax '.?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ....^\nERROR: optional_chaining_14:1:10: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .........^\nERROR: optional_chaining_14:1:28: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ...........................^", - }, - { - original: { - name: "optional_chaining_15", - expr: "[?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]", - value: { listValue: {} }, - }, - error: - "ERROR: optional_chaining_15:1:2: unsupported syntax '?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | .^\nERROR: optional_chaining_15:1:36: unsupported syntax '.?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | ...................................^", - }, - { - original: { - name: "optional_chaining_16", - expr: "optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: optional_chaining_16:1:26: unsupported syntax '?'\n | optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()\n | .........................^", - }, - { - original: { - name: "has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field", - expr: "has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - error: - "ERROR: has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:18: unsupported syntax '?'\n | has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)\n | .................^", - }, - { - original: { - name: "optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field", - expr: "optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - error: - "ERROR: optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:38: unsupported syntax '?'\n | optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()\n | .....................................^", - }, - { - original: { - name: "struct_map_optindex_field", - expr: "TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string", - container: "cel.expr.conformance.proto2", - value: { mapValue: {} }, - }, - error: - "ERROR: struct_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string\n | .............^", - }, - { - original: { - name: "struct_optional_ofNonZeroValue_map_optindex_field", - expr: "TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string", - container: "cel.expr.conformance.proto2", - value: { mapValue: {} }, - }, - error: - "ERROR: struct_optional_ofNonZeroValue_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string\n | .............^", - }, - { - original: { - name: "struct_map_optindex_field_nested", - expr: "TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string", - container: "cel.expr.conformance.proto2", - value: { - mapValue: { - entries: [ - { - key: { stringValue: "hello" }, - value: { stringValue: "world" }, - }, - ], - }, - }, - }, - error: - "ERROR: struct_map_optindex_field_nested:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string\n | .............^", - }, - { - original: { - name: "struct_list_optindex_field", - expr: "TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string", - container: "cel.expr.conformance.proto2", - value: { - listValue: { - values: [ - { stringValue: "greetings" }, - { stringValue: "world" }, - ], - }, - }, - }, - error: - "ERROR: struct_list_optindex_field:1:45: unsupported syntax '?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ............................................^\nERROR: struct_list_optindex_field:1:83: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ..................................................................................^", - }, - { - original: { - name: "optional_empty_map_optindex_hasValue", - expr: "optional.of({}).?c.hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: optional_empty_map_optindex_hasValue:1:16: unsupported syntax '.?'\n | optional.of({}).?c.hasValue()\n | ...............^", - }, - { - original: { - name: "empty_struct_optindex_hasValue", - expr: "TestAllTypes{}.?repeated_string.hasValue()", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - error: - "ERROR: empty_struct_optindex_hasValue:1:15: unsupported syntax '.?'\n | TestAllTypes{}.?repeated_string.hasValue()\n | ..............^", - }, - { - original: { - name: "optional_empty_struct_optindex_hasValue", - expr: "optional.of(TestAllTypes{}).?repeated_string.hasValue()", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - error: - "ERROR: optional_empty_struct_optindex_hasValue:1:28: unsupported syntax '.?'\n | optional.of(TestAllTypes{}).?repeated_string.hasValue()\n | ...........................^", - }, - { - original: { - name: "optional_none_optselect_hasValue", - expr: "optional.none().?repeated_string.hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: optional_none_optselect_hasValue:1:16: unsupported syntax '.?'\n | optional.none().?repeated_string.hasValue()\n | ...............^", - }, - { - original: { - name: "struct_optindex_value", - expr: "TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()", - container: "cel.expr.conformance.proto2", - value: { listValue: { values: [{ stringValue: "foo" }] } }, - }, - error: - "ERROR: struct_optindex_value:1:39: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()\n | ......................................^", - }, - { - original: { - name: "optional_struct_optindex_value", - expr: "optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()", - container: "cel.expr.conformance.proto2", - value: { listValue: { values: [{ stringValue: "foo" }] } }, - }, - error: - "ERROR: optional_struct_optindex_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()\n | ...................................................^", - }, - { - original: { - name: "optional_struct_optindex_index_value", - expr: "optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()", - container: "cel.expr.conformance.proto2", - value: { stringValue: "foo" }, - }, - error: - "ERROR: optional_struct_optindex_index_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()\n | ...................................................^", - }, - { - original: { - name: "empty_list_optindex_hasValue", - expr: "[][?0].hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: empty_list_optindex_hasValue:1:3: unsupported syntax '[?'\n | [][?0].hasValue()\n | ..^", - }, - { - original: { - name: "optional_empty_list_optindex_hasValue", - expr: "optional.of([])[?0].hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: optional_empty_list_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.of([])[?0].hasValue()\n | ...............^", - }, - { - original: { - name: "optional_none_optindex_hasValue", - expr: "optional.none()[?0].hasValue()", - value: { boolValue: false }, - }, - error: - "ERROR: optional_none_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.none()[?0].hasValue()\n | ...............^", - }, - { - original: { - name: "list_optindex_value", - expr: "['foo'][?0].value()", - value: { stringValue: "foo" }, - }, - error: - "ERROR: list_optindex_value:1:8: unsupported syntax '[?'\n | ['foo'][?0].value()\n | .......^", - }, - { - original: { - name: "optional_list_optindex_value", - expr: "optional.of(['foo'])[?0].value()", - value: { stringValue: "foo" }, - }, - error: - "ERROR: optional_list_optindex_value:1:21: unsupported syntax '[?'\n | optional.of(['foo'])[?0].value()\n | ....................^", - }, - { - original: { - name: "map_key_mixed_type_optindex_value", - expr: "{true: 1, 2: 2, 5u: 3}[?true].value()", - value: { int64Value: "1" }, - }, - error: - "ERROR: map_key_mixed_type_optindex_value:1:23: unsupported syntax '[?'\n | {true: 1, 2: 2, 5u: 3}[?true].value()\n | ......................^", - }, - { - original: { - name: "map_key_mixed_numbers_double_key_optindex_value", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()", - value: { doubleValue: 3 }, - }, - error: - "ERROR: map_key_mixed_numbers_double_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()\n | ..........................^", - }, - { - original: { - name: "map_key_mixed_numbers_uint_key_optindex_value", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()", - value: { doubleValue: 2 }, - }, - error: - "ERROR: map_key_mixed_numbers_uint_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()\n | ..........................^", - }, - { - original: { - name: "map_key_mixed_numbers_int_key_optindex_value", - expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()", - value: { doubleValue: 1 }, - }, - error: - "ERROR: map_key_mixed_numbers_int_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()\n | ..........................^", - }, - { - original: { - name: "optional_eq_none_none", - expr: "optional.none() == optional.none()", - value: { boolValue: true }, - }, - ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "optional_eq_none_int", - expr: "optional.none() == optional.of(1)", - value: { boolValue: false }, - }, - ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "optional_eq_int_none", - expr: "optional.of(1) == optional.none()", - value: { boolValue: false }, - }, - ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "optional_eq_int_int", - expr: "optional.of(1) == optional.of(1)", - value: { boolValue: true }, - }, - ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "optional_ne_none_none", - expr: "optional.none() != optional.none()", - value: { boolValue: false }, - }, - ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "optional_ne_none_int", - expr: "optional.none() != optional.of(1)", - value: { boolValue: true }, - }, - ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "optional_ne_int_none", - expr: "optional.of(1) != optional.none()", - value: { boolValue: true }, - }, - ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "optional_ne_int_int", - expr: "optional.of(1) != optional.of(1)", - value: { boolValue: false }, - }, - ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals", - type: "bool", - }, - { - original: { - name: "map_optional_has", - expr: "has({'foo': optional.none()}.foo)", - value: { boolValue: true }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "foo"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~test-only~~bool', - type: "bool", - }, - { - original: { - name: "map_optional_select_has", - expr: "has({'foo': optional.none()}.foo.bar)", - value: { boolValue: false }, - }, - ast: '{\n "foo"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo^#*expr.Expr_SelectExpr#.bar~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "foo"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~optional_type(dyn).bar~test-only~~bool', - type: "bool", - }, - { - original: { - name: "map_optional_entry_has", - expr: "has({?'foo': optional.none()}.foo)", - value: { boolValue: false }, - }, - error: - "ERROR: map_optional_entry_has:1:6: unsupported syntax '?'\n | has({?'foo': optional.none()}.foo)\n | .....^", - }, - ], - }, - ], - }, - { - name: "parse", - suites: [ - { - name: "nest", - tests: [ - { - original: { - name: "list_index", - description: - "Member = Member '[' Expr ']'. Nested indices are supported up to 12 times.", - expr: "a[a[a[a[a[a[a[a[a[a[a[a[0]]]]]]]]]]]]", - typeEnv: [ - { - name: "a", - ident: { - type: { listType: { elemType: { primitive: "INT64" } } }, - }, - }, - ], - bindings: { - a: { - value: { listValue: { values: [{ int64Value: "0" }] } }, - }, - }, - value: { int64Value: "0" }, - }, - ast: "_[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n 0~int\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n)~int^index_list", - type: "int", - }, - { - original: { - name: "message_literal", - description: - "Member = Member '{' [FieldInits] '}'. Nested messages supported up to 12 levels deep.", - expr: "NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{payload: TestAllTypes{single_int64: 137}}}}}}}}}}}}.payload.single_int64", - container: "cel.expr.conformance.proto3", - value: { int64Value: "0" }, - }, - ast: "NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n payload:TestAllTypes{\n single_int64:137^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.payload^#*expr.Expr_SelectExpr#.single_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n payload:cel.expr.conformance.proto3.TestAllTypes{\n single_int64:137~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int64~int", - type: "int", - }, - { - original: { - name: "funcall", - description: - "Primary = ['.'] IDENT ['(' [ExprList] ')']. Nested function calls supported up to 12 levels deep.", - expr: "int(uint(int(uint(int(uint(int(uint(int(uint(int(uint(7))))))))))))", - value: { int64Value: "7" }, - }, - ast: "int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7~int\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n)~int^uint64_to_int64", - type: "int", - }, - { - original: { - name: "list_literal", - description: - "Primary = '[' [ExprList] ']'. Nested list literals up to 12 levels deep.", - expr: "size([[[[[[[[[[[[0]]]]]]]]]]]])", - value: { int64Value: "1" }, - }, - ast: "size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0~int\n ]~list(int)\n ]~list(list(int))\n ]~list(list(list(int)))\n ]~list(list(list(list(int))))\n ]~list(list(list(list(list(int)))))\n ]~list(list(list(list(list(list(int))))))\n ]~list(list(list(list(list(list(list(int)))))))\n ]~list(list(list(list(list(list(list(list(int))))))))\n ]~list(list(list(list(list(list(list(list(list(int)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(int))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(int)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(int))))))))))))\n)~int^size_list", - type: "int", - }, - { - original: { - name: "map_literal", - description: - "Primary = '{' [MapInits] '}'. Nested map literals up to 12 levels deep.", - expr: "size({0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: 'foo'}}}}}}}}}}}})", - value: { int64Value: "1" }, - }, - ast: 'size(\n {\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'size(\n {\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:"foo"~string\n }~map(int, string)\n }~map(int, map(int, string))\n }~map(int, map(int, map(int, string)))\n }~map(int, map(int, map(int, map(int, string))))\n }~map(int, map(int, map(int, map(int, map(int, string)))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, string))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))))\n)~int^size_map', - type: "int", - }, - { - original: { - name: "parens", - description: "Primary = '(' Expr ')'", - expr: "((((((((((((((((((((((((((((((((7))))))))))))))))))))))))))))))))", - value: { int64Value: "7" }, - }, - error: - "ERROR: parens:-1:0: expression recursion limit exceeded: 32", - }, - ], - }, - { - name: "repeat", - tests: [ - { - original: { - name: "conditional", - description: - "Expr = ConditionalOr ['?' ConditionalOr ':' Expr]. Chained ternary operators up to 24 levels.", - expr: "true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : false", - value: { boolValue: true }, - }, - ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n false~bool\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n)~bool^conditional", - type: "bool", - }, - { - original: { - name: "or", - description: - "ConditionalOr = [ConditionalOr '||'] ConditionalAnd. Logical OR statements with 32 conditions.", - expr: "false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || true", - value: { boolValue: true }, - }, - ast: "_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n true~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n)~bool^logical_or", - type: "bool", - }, - { - original: { - name: "and", - description: - "ConditionalAnd = [ConditionalAnd '\u0026\u0026'] Relation. Logical AND statements with 32 conditions.", - expr: "true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 false", - value: { boolValue: false }, - }, - ast: "_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n false~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n)~bool^logical_and", - type: "bool", - }, - { - original: { - name: "add_sub", - description: - "Addition = [Addition ('+' | '-')] Multiplication. Addition operators are supported up to 24 times consecutively.", - expr: "3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3", - value: { int64Value: "3" }, - }, - ast: "_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3~int,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "mul_div", - description: - "Multiplication = [Multiplication ('*' | '/' | '%')] Unary. Multiplication operators are supported up to 24 times consecutively.", - expr: "4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4", - value: { int64Value: "4" }, - }, - ast: "_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4~int,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "not", - description: "Unary = '!' {'!'} Member", - expr: "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!true", - value: { boolValue: true }, - }, - ast: "true^#*expr.Constant_BoolValue#", - checkedAst: "true~bool", - type: "bool", - }, - { - original: { - name: "unary_neg", - description: "Unary = '-' {'-'} Member", - expr: "--------------------------------19", - value: { int64Value: "19" }, - }, - ast: "19^#*expr.Constant_Int64Value#", - checkedAst: "19~int", - type: "int", - }, - { - original: { - name: "select", - description: - "Member = Member '.' IDENT ['(' [ExprList] ')']. Selection is supported up to 12 times consecutively.", - expr: "NestedTestAllTypes{}.child.child.child.child.child.child.child.child.child.child.payload.single_int32", - container: "cel.expr.conformance.proto3", - value: { int64Value: "0" }, - }, - ast: "NestedTestAllTypes{}^#*expr.Expr_StructExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.payload^#*expr.Expr_SelectExpr#.single_int32^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.NestedTestAllTypes{}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int32~int", - type: "int", - }, - { - original: { - name: "index", - description: - "Member = Member '[' Expr ']'. Indexing is supported up to 12 times consecutively.", - expr: "[[[[[[[[[[[['foo']]]]]]]]]]]][0][0][0][0][0][0][0][0][0][0][0][0]", - value: { stringValue: "foo" }, - }, - ast: '_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n "foo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n "foo"~string\n ]~list(string)\n ]~list(list(string))\n ]~list(list(list(string)))\n ]~list(list(list(list(string))))\n ]~list(list(list(list(list(string)))))\n ]~list(list(list(list(list(list(string))))))\n ]~list(list(list(list(list(list(list(string)))))))\n ]~list(list(list(list(list(list(list(list(string))))))))\n ]~list(list(list(list(list(list(list(list(list(string)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(string))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(string)))))))))))),\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(string))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(string)))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(string))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(string)))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(string))))))^index_list,\n 0~int\n )~list(list(list(list(list(string)))))^index_list,\n 0~int\n )~list(list(list(list(string))))^index_list,\n 0~int\n )~list(list(list(string)))^index_list,\n 0~int\n )~list(list(string))^index_list,\n 0~int\n )~list(string)^index_list,\n 0~int\n)~string^index_list', - type: "string", - }, - { - original: { - name: "list_literal", - description: - "Primary = '[' [ExprList] ']'. List literals with up to 32 elements.", - expr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31][17]", - value: { int64Value: "17" }, - }, - ast: "_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#,\n 11^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#,\n 14^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#,\n 16^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#,\n 18^#*expr.Constant_Int64Value#,\n 19^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#,\n 21^#*expr.Constant_Int64Value#,\n 22^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#,\n 24^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#,\n 26^#*expr.Constant_Int64Value#,\n 27^#*expr.Constant_Int64Value#,\n 28^#*expr.Constant_Int64Value#,\n 29^#*expr.Constant_Int64Value#,\n 30^#*expr.Constant_Int64Value#,\n 31^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int,\n 6~int,\n 7~int,\n 8~int,\n 9~int,\n 10~int,\n 11~int,\n 12~int,\n 13~int,\n 14~int,\n 15~int,\n 16~int,\n 17~int,\n 18~int,\n 19~int,\n 20~int,\n 21~int,\n 22~int,\n 23~int,\n 24~int,\n 25~int,\n 26~int,\n 27~int,\n 28~int,\n 29~int,\n 30~int,\n 31~int\n ]~list(int),\n 17~int\n)~int^index_list", - type: "int", - }, - { - original: { - name: "map_literal", - description: - "Primary = '{' [MapInits] '}'. Map literals with up to 32 entries.", - expr: "{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine', 10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen', 14: 'fourteen', 15: 'fifteen', 16: 'sixteen', 17: 'seventeen', 18: 'eighteen', 19: 'nineteen', 20: 'twenty', 21: 'twenty-one', 22: 'twenty-two', 23: 'twenty-three', 24: 'twenty-four', 25: 'twenty-five', 26: 'twenty-six', 27: 'twenty-seven', 28: 'twenty-eight', 29: 'twenty-nine', 30: 'thirty', 31: 'thirty-one'}[17]", - value: { stringValue: "seventeen" }, - }, - ast: '_[_](\n {\n 0^#*expr.Constant_Int64Value#:"zero"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:"one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:"three"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 4^#*expr.Constant_Int64Value#:"four"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:"five"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:"six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:"seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:"eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 9^#*expr.Constant_Int64Value#:"nine"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 10^#*expr.Constant_Int64Value#:"ten"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 11^#*expr.Constant_Int64Value#:"eleven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 12^#*expr.Constant_Int64Value#:"twelve"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 13^#*expr.Constant_Int64Value#:"thirteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 14^#*expr.Constant_Int64Value#:"fourteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 15^#*expr.Constant_Int64Value#:"fifteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 16^#*expr.Constant_Int64Value#:"sixteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 17^#*expr.Constant_Int64Value#:"seventeen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 18^#*expr.Constant_Int64Value#:"eighteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 19^#*expr.Constant_Int64Value#:"nineteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 20^#*expr.Constant_Int64Value#:"twenty"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 21^#*expr.Constant_Int64Value#:"twenty-one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 22^#*expr.Constant_Int64Value#:"twenty-two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 23^#*expr.Constant_Int64Value#:"twenty-three"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 24^#*expr.Constant_Int64Value#:"twenty-four"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 25^#*expr.Constant_Int64Value#:"twenty-five"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 26^#*expr.Constant_Int64Value#:"twenty-six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 27^#*expr.Constant_Int64Value#:"twenty-seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 28^#*expr.Constant_Int64Value#:"twenty-eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 29^#*expr.Constant_Int64Value#:"twenty-nine"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 30^#*expr.Constant_Int64Value#:"thirty"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 31^#*expr.Constant_Int64Value#:"thirty-one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n 0~int:"zero"~string,\n 1~int:"one"~string,\n 2~int:"two"~string,\n 3~int:"three"~string,\n 4~int:"four"~string,\n 5~int:"five"~string,\n 6~int:"six"~string,\n 7~int:"seven"~string,\n 8~int:"eight"~string,\n 9~int:"nine"~string,\n 10~int:"ten"~string,\n 11~int:"eleven"~string,\n 12~int:"twelve"~string,\n 13~int:"thirteen"~string,\n 14~int:"fourteen"~string,\n 15~int:"fifteen"~string,\n 16~int:"sixteen"~string,\n 17~int:"seventeen"~string,\n 18~int:"eighteen"~string,\n 19~int:"nineteen"~string,\n 20~int:"twenty"~string,\n 21~int:"twenty-one"~string,\n 22~int:"twenty-two"~string,\n 23~int:"twenty-three"~string,\n 24~int:"twenty-four"~string,\n 25~int:"twenty-five"~string,\n 26~int:"twenty-six"~string,\n 27~int:"twenty-seven"~string,\n 28~int:"twenty-eight"~string,\n 29~int:"twenty-nine"~string,\n 30~int:"thirty"~string,\n 31~int:"thirty-one"~string\n }~map(int, string),\n 17~int\n)~string^index_map', - type: "string", - }, - { - original: { - name: "message_literal", - description: - "Member = Member '{' [FieldInits] '}'. Message literals with up to 32 fields.", - expr: "TestAllTypes{single_int32: 5, single_int64: 10, single_uint32: 15u, single_uint64: 20u, single_sint32: 25, single_sint64: 30, single_fixed32: 35u, single_fixed64: 40u, single_float: 45.0, single_double: 50.0, single_bool: true, single_string: 'sixty', single_bytes: b'sixty-five', single_value: 70.0, single_int64_wrapper: 75, single_int32_wrapper: 80, single_double_wrapper: 85.0, single_float_wrapper: 90.0, single_uint64_wrapper: 95u, single_uint32_wrapper: 100u, single_string_wrapper: 'one hundred five', single_bool_wrapper: true, repeated_int32: [115], repeated_int64: [120], repeated_uint32: [125u], repeated_uint64: [130u], repeated_sint32: [135], repeated_sint64: [140], repeated_fixed32: [145u], repeated_fixed64: [150u], repeated_sfixed32: [155], repeated_float: [160.0]}.single_sint64", - container: "cel.expr.conformance.proto3", - value: { int64Value: "30" }, - }, - ast: 'TestAllTypes{\n single_int32:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int64:10^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32:15u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64:20u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint32:25^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint64:30^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed32:35u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed64:40u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_float:45^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_double:50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"sixty"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bytes:b"sixty-five"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n single_value:70^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_int64_wrapper:75^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int32_wrapper:80^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_double_wrapper:85^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_float_wrapper:90^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64_wrapper:95u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32_wrapper:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string_wrapper:"one hundred five"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int32:[\n 115^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int64:[\n 120^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint32:[\n 125u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint64:[\n 130u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint32:[\n 135^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint64:[\n 140^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed32:[\n 145u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed64:[\n 150u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sfixed32:[\n 155^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_float:[\n 160^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint64^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_int32:5~int,\n single_int64:10~int,\n single_uint32:15u~uint,\n single_uint64:20u~uint,\n single_sint32:25~int,\n single_sint64:30~int,\n single_fixed32:35u~uint,\n single_fixed64:40u~uint,\n single_float:45~double,\n single_double:50~double,\n single_bool:true~bool,\n single_string:"sixty"~string,\n single_bytes:b"sixty-five"~bytes,\n single_value:70~double,\n single_int64_wrapper:75~int,\n single_int32_wrapper:80~int,\n single_double_wrapper:85~double,\n single_float_wrapper:90~double,\n single_uint64_wrapper:95u~uint,\n single_uint32_wrapper:100u~uint,\n single_string_wrapper:"one hundred five"~string,\n single_bool_wrapper:true~bool,\n repeated_int32:[\n 115~int\n ]~list(int),\n repeated_int64:[\n 120~int\n ]~list(int),\n repeated_uint32:[\n 125u~uint\n ]~list(uint),\n repeated_uint64:[\n 130u~uint\n ]~list(uint),\n repeated_sint32:[\n 135~int\n ]~list(int),\n repeated_sint64:[\n 140~int\n ]~list(int),\n repeated_fixed32:[\n 145u~uint\n ]~list(uint),\n repeated_fixed64:[\n 150u~uint\n ]~list(uint),\n repeated_sfixed32:[\n 155~int\n ]~list(int),\n repeated_float:[\n 160~double\n ]~list(double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_sint64~int', - type: "int", - }, - ], - }, - { - name: "string_literals", - tests: [ - { - original: { - name: "single_quoted", - expr: "'hello'", - value: { stringValue: "hello" }, - }, - ast: '"hello"^#*expr.Constant_StringValue#', - checkedAst: '"hello"~string', - type: "string", - }, - { - original: { - name: "double_quoted", - expr: '"hello"', - value: { stringValue: "hello" }, - }, - ast: '"hello"^#*expr.Constant_StringValue#', - checkedAst: '"hello"~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted", - expr: "'''hello'''", - value: { stringValue: "hello" }, - }, - ast: '"hello"^#*expr.Constant_StringValue#', - checkedAst: '"hello"~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted", - expr: '"""hello"""', - value: { stringValue: "hello" }, - }, - ast: '"hello"^#*expr.Constant_StringValue#', - checkedAst: '"hello"~string', - type: "string", - }, - { - original: { - name: "single_quoted_escaped_punctuation", - expr: "' \\\\ \\? \\\" \\' \\` '", - value: { stringValue: " \\ ? \" ' ` " }, - }, - ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', - checkedAst: '" \\\\ ? \\" \' ` "~string', - type: "string", - }, - { - original: { - name: "double_quoted_escaped_punctuation", - expr: '" \\\\ \\? \\" \\\' \\` "', - value: { stringValue: " \\ ? \" ' ` " }, - }, - ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', - checkedAst: '" \\\\ ? \\" \' ` "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_escaped_punctuation", - expr: "''' \\\\ \\? \\\" \\' \\` '''", - value: { stringValue: " \\ ? \" ' ` " }, - }, - ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', - checkedAst: '" \\\\ ? \\" \' ` "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_escaped_punctuation", - expr: '""" \\\\ \\? \\" \\\' \\` """', - value: { stringValue: " \\ ? \" ' ` " }, - }, - ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', - checkedAst: '" \\\\ ? \\" \' ` "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_unescaped_punctuation", - expr: "''' ? \" ' ` '''", - value: { stringValue: " ? \" ' ` " }, - }, - ast: '" ? \\" \' ` "^#*expr.Constant_StringValue#', - checkedAst: '" ? \\" \' ` "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_unescaped_punctuation", - expr: '""" ? " \' ` """', - value: { stringValue: " ? \" ' ` " }, - }, - ast: '" ? \\" \' ` "^#*expr.Constant_StringValue#', - checkedAst: '" ? \\" \' ` "~string', - type: "string", - }, - { - original: { - name: "single_quoted_escaped_special_control_characters", - expr: "' \\a \\b \\f \\t \\v '", - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "double_quoted_escaped_special_control_characters", - expr: '" \\a \\b \\f \\t \\v "', - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "single_quoted_unescaped_special_control_characters", - expr: "' \u0007 \b \f \t \u000b '", - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "double_quoted_unescaped_special_control_characters", - expr: '" \u0007 \b \f \t \u000b "', - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_escaped_special_control_characters", - expr: "''' \\a \\b \\f \\t \\v '''", - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_escaped_special_control_characters", - expr: '""" \\a \\b \\f \\t \\v """', - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_unescaped_special_control_characters", - expr: "''' \u0007 \b \f \t \u000b '''", - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_unescaped_special_control_characters", - expr: '""" \u0007 \b \f \t \u000b """', - value: { stringValue: " \u0007 \b \f \t \u000b " }, - }, - ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', - checkedAst: '" \\a \\b \\f \\t \\v "~string', - type: "string", - }, - { - original: { - name: "single_quoted_escaped_line_feed", - expr: "' \\n '", - value: { stringValue: " \n " }, - }, - ast: '" \\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\n "~string', - type: "string", - }, - { - original: { - name: "double_quoted_escaped_line_feed", - expr: '" \\n "', - value: { stringValue: " \n " }, - }, - ast: '" \\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\n "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_escaped_line_feed", - expr: "''' \\n '''", - value: { stringValue: " \n " }, - }, - ast: '" \\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\n "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_escaped_line_feed", - expr: '""" \\n """', - value: { stringValue: " \n " }, - }, - ast: '" \\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\n "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_unescaped_line_feed", - expr: "''' \n '''", - value: { stringValue: " \n " }, - }, - ast: '" \\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\n "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_unescaped_line_feed", - expr: '""" \n """', - value: { stringValue: " \n " }, - }, - ast: '" \\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\n "~string', - type: "string", - }, - { - original: { - name: "single_quoted_escaped_carriage_return", - expr: "' \\r '", - value: { stringValue: " \r " }, - }, - ast: '" \\r "^#*expr.Constant_StringValue#', - checkedAst: '" \\r "~string', - type: "string", - }, - { - original: { - name: "double_quoted_escaped_carriage_return", - expr: '" \\r "', - value: { stringValue: " \r " }, - }, - ast: '" \\r "^#*expr.Constant_StringValue#', - checkedAst: '" \\r "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_escaped_carriage_return", - expr: "''' \\r '''", - value: { stringValue: " \r " }, - }, - ast: '" \\r "^#*expr.Constant_StringValue#', - checkedAst: '" \\r "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_escaped_carriage_return", - expr: '""" \\r """', - value: { stringValue: " \r " }, - }, - ast: '" \\r "^#*expr.Constant_StringValue#', - checkedAst: '" \\r "~string', - type: "string", - }, - { - original: { - name: "single_quoted_escaped_windows_line_end", - expr: "' \\r\\n '", - value: { stringValue: " \r\n " }, - }, - ast: '" \\r\\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\r\\n "~string', - type: "string", - }, - { - original: { - name: "double_quoted_escaped_windows_line_end", - expr: '" \\r\\n "', - value: { stringValue: " \r\n " }, - }, - ast: '" \\r\\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\r\\n "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_escaped_windows_line_end", - expr: "''' \\r\\n '''", - value: { stringValue: " \r\n " }, - }, - ast: '" \\r\\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\r\\n "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_escaped_windows_line_end", - expr: '""" \\r\\n """', - value: { stringValue: " \r\n " }, - }, - ast: '" \\r\\n "^#*expr.Constant_StringValue#', - checkedAst: '" \\r\\n "~string', - type: "string", - }, - { - original: { - name: "single_quoted_escaped_all_control_characters", - expr: "' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '", - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "double_quoted_escaped_all_control_characters", - expr: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F "', - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "single_quoted_unescaped_all_control_characters", - expr: "' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '", - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "double_quoted_unescaped_all_control_characters", - expr: '" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "', - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_escaped_all_control_characters", - expr: "''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''", - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_escaped_all_control_characters", - expr: '""" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F """', - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_unescaped_all_control_characters", - expr: "''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''", - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_unescaped_all_control_characters", - expr: '""" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  """', - value: { - stringValue: - " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", - }, - }, - ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', - checkedAst: - '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', - type: "string", - }, - { - original: { - name: "single_quoted_octal_escapes", - expr: "' \\000 \\012 \\177 '", - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "double_quoted_octal_escapes", - expr: '" \\000 \\012 \\177 "', - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_octal_escapes", - expr: "''' \\000 \\012 \\177 '''", - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_octal_escapes", - expr: '""" \\000 \\012 \\177 """', - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "single_quoted_lower_x_escapes", - expr: "' \\x00 \\x0A \\x7F '", - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "double_quoted_lower_x_escapes", - expr: '" \\x00 \\x0A \\x7F "', - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_lower_x_escapes", - expr: "''' \\x00 \\x0A \\x7F '''", - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_lower_x_escapes", - expr: '""" \\x00 \\x0A \\x7F """', - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "single_quoted_upper_x_escapes", - expr: "' \\X00 \\X0A \\X7F '", - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "double_quoted_upper_x_escapes", - expr: '" \\X00 \\X0A \\X7F "', - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_upper_x_escapes", - expr: "''' \\X00 \\X0A \\X7F '''", - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_upper_x_escapes", - expr: '""" \\X00 \\X0A \\X7F """', - value: { stringValue: " \u0000 \n  " }, - }, - ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f "~string', - type: "string", - }, - { - original: { - name: "single_quoted_lower_u_escapes", - expr: "' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '", - value: { stringValue: " \u0000 \n  Ā  " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', - type: "string", - }, - { - original: { - name: "double_quoted_lower_u_escapes", - expr: '" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB "', - value: { stringValue: " \u0000 \n  Ā  " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_lower_u_escapes", - expr: "''' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '''", - value: { stringValue: " \u0000 \n  Ā  " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_lower_u_escapes", - expr: '""" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB """', - value: { stringValue: " \u0000 \n  Ā  " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', - type: "string", - }, - { - original: { - name: "single_quoted_upper_u_escapes", - expr: "' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '", - value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', - type: "string", - }, - { - original: { - name: "double_quoted_upper_u_escapes", - expr: '" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C "', - value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', - type: "string", - }, - { - original: { - name: "triple_single_quoted_upper_u_escapes", - expr: "''' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '''", - value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', - type: "string", - }, - { - original: { - name: "triple_double_quoted_upper_u_escapes", - expr: '""" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C """', - value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, - }, - ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', - checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', - type: "string", - }, - { - original: { - name: "mixed_case_hex_single_quoted_escapes", - expr: "' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '", - value: { stringValue: " J K L M ƫ ƫ " }, - }, - ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', - checkedAst: '" J K L M ƫ ƫ "~string', - type: "string", - }, - { - original: { - name: "mixed_case_hex_double_quoted_escapes", - expr: '" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB "', - value: { stringValue: " J K L M ƫ ƫ " }, - }, - ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', - checkedAst: '" J K L M ƫ ƫ "~string', - type: "string", - }, - { - original: { - name: "mixed_case_hex_triple_single_quoted_escapes", - expr: "''' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '''", - value: { stringValue: " J K L M ƫ ƫ " }, - }, - ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', - checkedAst: '" J K L M ƫ ƫ "~string', - type: "string", - }, - { - original: { - name: "mixed_case_hex_triple_double_quoted_escapes", - expr: '""" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB """', - value: { stringValue: " J K L M ƫ ƫ " }, - }, - ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', - checkedAst: '" J K L M ƫ ƫ "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_single_quoted_escapes", - expr: "' \\U00088888 '", - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_double_quoted_escapes", - expr: '" \\U00088888 "', - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_triple_single_quoted_escapes", - expr: "''' \\U00088888 '''", - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_triple_double_quoted_escapes", - expr: '""" \\U00088888 """', - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_single_quoted_unescaped", - expr: "' 򈢈 '", - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_double_quoted_unescaped", - expr: '" 򈢈 "', - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_triple_single_quoted_unescaped", - expr: "''' 򈢈 '''", - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "unassigned_code_point_triple_double_quoted_unescaped", - expr: '""" 򈢈 """', - value: { stringValue: " 򈢈 " }, - }, - ast: '" \\U00088888 "^#*expr.Constant_StringValue#', - checkedAst: '" \\U00088888 "~string', - type: "string", - }, - { - original: { - name: "raw_single_quoted_escapes", - expr: "r' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", - value: { - stringValue: - ' \\\\ \\? \\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ', - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "raw_double_quoted_escapes", - expr: 'r" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', - value: { - stringValue: - " \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "raw_triple_single_quoted_escapes", - expr: "r''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", - value: { - stringValue: - " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "raw_triple_double_quoted_escapes", - expr: 'r""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', - value: { - stringValue: - " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "upper_raw_single_quoted_escapes", - expr: "R' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", - value: { - stringValue: - ' \\\\ \\? \\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ', - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "upper_raw_double_quoted_escapes", - expr: 'R" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', - value: { - stringValue: - " \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "upper_raw_triple_single_quoted_escapes", - expr: "R''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", - value: { - stringValue: - " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - { - original: { - name: "upper_raw_triple_double_quoted_escapes", - expr: 'R""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', - value: { - stringValue: - " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", - }, - }, - ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', - checkedAst: - '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', - type: "string", - }, - ], - }, - { - name: "bytes_literals", - tests: [ - { - original: { - name: "single_quoted", - expr: "b'hello'", - value: { bytesValue: "aGVsbG8=" }, - }, - ast: 'b"hello"^#*expr.Constant_BytesValue#', - checkedAst: 'b"hello"~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted", - expr: 'b"hello"', - value: { bytesValue: "aGVsbG8=" }, - }, - ast: 'b"hello"^#*expr.Constant_BytesValue#', - checkedAst: 'b"hello"~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted", - expr: "b'''hello'''", - value: { bytesValue: "aGVsbG8=" }, - }, - ast: 'b"hello"^#*expr.Constant_BytesValue#', - checkedAst: 'b"hello"~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted", - expr: 'b"""hello"""', - value: { bytesValue: "aGVsbG8=" }, - }, - ast: 'b"hello"^#*expr.Constant_BytesValue#', - checkedAst: 'b"hello"~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_escaped_punctuation", - expr: "b' \\\\ \\? \\\" \\' \\` '", - value: { bytesValue: "IFwgPyAiICcgYCA=" }, - }, - ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_escaped_punctuation", - expr: 'b" \\\\ \\? \\" \\\' \\` "', - value: { bytesValue: "IFwgPyAiICcgYCA=" }, - }, - ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_escaped_punctuation", - expr: "b''' \\\\ \\? \\\" \\' \\` '''", - value: { bytesValue: "IFwgPyAiICcgYCA=" }, - }, - ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_escaped_punctuation", - expr: 'b""" \\\\ \\? \\" \\\' \\` """', - value: { bytesValue: "IFwgPyAiICcgYCA=" }, - }, - ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_unescaped_punctuation", - expr: "b''' ? \" ' ` '''", - value: { bytesValue: "ID8gIiAnIGAg" }, - }, - ast: 'b" ? \\" \' ` "^#*expr.Constant_BytesValue#', - checkedAst: 'b" ? \\" \' ` "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_unescaped_punctuation", - expr: 'b""" ? " \' ` """', - value: { bytesValue: "ID8gIiAnIGAg" }, - }, - ast: 'b" ? \\" \' ` "^#*expr.Constant_BytesValue#', - checkedAst: 'b" ? \\" \' ` "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_escaped_special_control_characters", - expr: "b' \\a \\b \\f \\t \\v '", - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_escaped_special_control_characters", - expr: 'b" \\a \\b \\f \\t \\v "', - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_unescaped_special_control_characters", - expr: "b' \u0007 \b \f \t \u000b '", - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_unescaped_special_control_characters", - expr: 'b" \u0007 \b \f \t \u000b "', - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_escaped_special_control_characters", - expr: "b''' \\a \\b \\f \\t \\v '''", - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_escaped_special_control_characters", - expr: 'b""" \\a \\b \\f \\t \\v """', - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_unescaped_special_control_characters", - expr: "b''' \u0007 \b \f \t \u000b '''", - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_unescaped_special_control_characters", - expr: 'b""" \u0007 \b \f \t \u000b """', - value: { bytesValue: "IAcgCCAMIAkgCyA=" }, - }, - ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_escaped_line_feed", - expr: "b' \\n '", - value: { bytesValue: "IAog" }, - }, - ast: 'b" \\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\n "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_escaped_line_feed", - expr: 'b" \\n "', - value: { bytesValue: "IAog" }, - }, - ast: 'b" \\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\n "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_escaped_line_feed", - expr: "b''' \\n '''", - value: { bytesValue: "IAog" }, - }, - ast: 'b" \\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\n "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_escaped_line_feed", - expr: 'b""" \\n """', - value: { bytesValue: "IAog" }, - }, - ast: 'b" \\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\n "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_unescaped_line_feed", - expr: "b''' \n '''", - value: { bytesValue: "IAog" }, - }, - ast: 'b" \\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\n "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_unescaped_line_feed", - expr: 'b""" \n """', - value: { bytesValue: "IAog" }, - }, - ast: 'b" \\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\n "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_escaped_carriage_return", - expr: "b' \\r '", - value: { bytesValue: "IA0g" }, - }, - ast: 'b" \\r "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_escaped_carriage_return", - expr: 'b" \\r "', - value: { bytesValue: "IA0g" }, - }, - ast: 'b" \\r "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_escaped_carriage_return", - expr: "b''' \\r '''", - value: { bytesValue: "IA0g" }, - }, - ast: 'b" \\r "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_escaped_carriage_return", - expr: 'b""" \\r """', - value: { bytesValue: "IA0g" }, - }, - ast: 'b" \\r "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_escaped_windows_line_end", - expr: "b' \\r\\n '", - value: { bytesValue: "IA0KIA==" }, - }, - ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r\\n "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_escaped_windows_line_end", - expr: 'b" \\r\\n "', - value: { bytesValue: "IA0KIA==" }, - }, - ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r\\n "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_escaped_windows_line_end", - expr: "b''' \\r\\n '''", - value: { bytesValue: "IA0KIA==" }, - }, - ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r\\n "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_escaped_windows_line_end", - expr: 'b""" \\r\\n """', - value: { bytesValue: "IA0KIA==" }, - }, - ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\r\\n "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_escaped_all_control_characters", - expr: "b' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '", - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_escaped_all_control_characters", - expr: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F "', - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_unescaped_all_control_characters", - expr: "b' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '", - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_unescaped_all_control_characters", - expr: 'b" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "', - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_escaped_all_control_characters", - expr: "b''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''", - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_escaped_all_control_characters", - expr: 'b""" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F """', - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_unescaped_all_control_characters", - expr: "b''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''", - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_unescaped_all_control_characters", - expr: 'b""" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  """', - value: { - bytesValue: - "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", - }, - }, - ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_octal_escapes", - expr: "b' \\000 \\012 \\177 \\377 '", - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_octal_escapes", - expr: 'b" \\000 \\012 \\177 \\377 "', - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_octal_escapes", - expr: "b''' \\000 \\012 \\177 \\377 '''", - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_octal_escapes", - expr: 'b""" \\000 \\012 \\177 \\377 """', - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_lower_x_escapes", - expr: "b' \\x00 \\x0A \\x7F \\xFF '", - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_lower_x_escapes", - expr: 'b" \\x00 \\x0A \\x7F \\xFF "', - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_lower_x_escapes", - expr: "b''' \\x00 \\x0A \\x7F \\xFF '''", - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_lower_x_escapes", - expr: 'b""" \\x00 \\x0A \\x7F \\xFF """', - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "single_quoted_upper_x_escapes", - expr: "b' \\X00 \\X0A \\X7F \\XFF '", - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "double_quoted_upper_x_escapes", - expr: 'b" \\X00 \\X0A \\X7F \\XFF "', - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_single_quoted_upper_x_escapes", - expr: "b''' \\X00 \\X0A \\X7F \\XFF '''", - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "triple_double_quoted_upper_x_escapes", - expr: 'b""" \\X00 \\X0A \\X7F \\XFF """', - value: { bytesValue: "IAAgCiB/IP8g" }, - }, - ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', - checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', - type: "bytes", - }, - { - original: { - name: "mixed_case_hex_single_quoted_escapes", - expr: "B' \\x4a \\x4B \\X4c \\X4D '", - value: { bytesValue: "IEogSyBMIE0g" }, - }, - ast: 'b" J K L M "^#*expr.Constant_BytesValue#', - checkedAst: 'b" J K L M "~bytes', - type: "bytes", - }, - { - original: { - name: "mixed_case_hex_double_quoted_escapes", - expr: 'B" \\x4a \\x4B \\X4c \\X4D "', - value: { bytesValue: "IEogSyBMIE0g" }, - }, - ast: 'b" J K L M "^#*expr.Constant_BytesValue#', - checkedAst: 'b" J K L M "~bytes', - type: "bytes", - }, - { - original: { - name: "mixed_case_hex_triple_single_quoted_escapes", - expr: "B''' \\x4a \\x4B \\X4c \\X4D '''", - value: { bytesValue: "IEogSyBMIE0g" }, - }, - ast: 'b" J K L M "^#*expr.Constant_BytesValue#', - checkedAst: 'b" J K L M "~bytes', - type: "bytes", - }, - { - original: { - name: "mixed_case_hex_triple_double_quoted_escapes", - expr: 'B""" \\x4a \\x4B \\X4c \\X4D """', - value: { bytesValue: "IEogSyBMIE0g" }, - }, - ast: 'b" J K L M "^#*expr.Constant_BytesValue#', - checkedAst: 'b" J K L M "~bytes', - type: "bytes", - }, - { - original: { - name: "raw_single_quoted_escapes", - expr: "br' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", - value: { - bytesValue: - "IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "raw_double_quoted_escapes", - expr: 'br" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', - value: { - bytesValue: - "IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "raw_triple_single_quoted_escapes", - expr: "br''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", - value: { - bytesValue: - "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "raw_triple_double_quoted_escapes", - expr: 'br""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', - value: { - bytesValue: - "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "upper_raw_single_quoted_escapes", - expr: "bR' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", - value: { - bytesValue: - "IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "upper_raw_double_quoted_escapes", - expr: 'bR" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', - value: { - bytesValue: - "IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "upper_raw_triple_single_quoted_escapes", - expr: "bR''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", - value: { - bytesValue: - "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - { - original: { - name: "upper_raw_triple_double_quoted_escapes", - expr: 'bR""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', - value: { - bytesValue: - "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", - }, - }, - ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', - checkedAst: - 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', - type: "bytes", - }, - ], - }, - { - name: "whitespace", - tests: [ - { - original: { - name: "spaces", - description: "Check that spaces are ignored.", - expr: "[ . cel. expr .conformance. proto3. TestAllTypes { single_int64 : int ( 17 ) } . single_int64 ] [ 0 ] == ( 18 - 1 ) \u0026\u0026 ! false ? 1 : 2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - { - original: { - name: "tabs", - description: "Check that tabs (`\\t`) are ignored.", - expr: "[\t.\tcel.\texpr\t.conformance.\tproto3.\tTestAllTypes\t{\tsingle_int64\t:\tint\t(\t17\t)\t}\t.\tsingle_int64\t]\t[\t0\t]\t==\t(\t18\t-\t1\t)\t\u0026\u0026\t!\tfalse\t?\t1\t:\t2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - { - original: { - name: "new_lines", - description: "Check that new lines (`\\n`) are ignored.", - expr: "[\n.\ncel.\nexpr\n.conformance.\nproto3.\nTestAllTypes\n{\nsingle_int64\n:\nint\n(\n17\n)\n}\n.\nsingle_int64\n]\n[\n0\n]\n==\n(\n18\n-\n1\n)\n\u0026\u0026\n!\nfalse\n?\n1\n:\n2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - { - original: { - name: "new_pages", - description: "Check that new pages (`\\f`) are ignored.", - expr: "[\f.\fcel.\fexpr\f.conformance.\fproto3.\fTestAllTypes\f{\fsingle_int64\f:\fint\f(\f17\f)\f}\f.\fsingle_int64\f]\f[\f0\f]\f==\f(\f18\f-\f1\f)\f\u0026\u0026\f!\ffalse\f?\f1\f:\f2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - { - original: { - name: "carriage_returns", - description: "Check that carriage returns (`\\r`) are ignored.", - expr: "[\r.\rcel.\rexpr\r.conformance.\rproto3.\rTestAllTypes\r{\rsingle_int64\r:\rint\r(\r17\r)\r}\r.\rsingle_int64\r]\r[\r0\r]\r==\r(\r18\r-\r1\r)\r\u0026\u0026\r!\rfalse\r?\r1\r:\r2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - ], - }, - { - name: "comments", - tests: [ - { - original: { - name: "new_line_terminated", - description: - "Check that new-line-terminated comments are ignored.", - expr: "[// @\n.// @\ncel.// @\nexpr// @\n.conformance.// @\nproto3.// @\nTestAllTypes// @\n{// @\nsingle_int64// @\n:// @\nint// @\n(// @\n17// @\n)// @\n}// @\n.// @\nsingle_int64// @\n]// @\n[// @\n0// @\n]// @\n==// @\n(// @\n18// @\n-// @\n1// @\n)// @\n\u0026\u0026// @\n!// @\nfalse// @\n?// @\n1// @\n:// @\n2", - value: { int64Value: "1" }, - }, - ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", - type: "int", - }, - ], - }, - { - name: "selectors", - tests: [ - { - original: { - name: "as", - description: "Check that `as` can be used as a selector.", - expr: "{ 'as': 1 }.as", - value: { int64Value: "1" }, - }, - ast: '{\n "as"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.as^#*expr.Expr_SelectExpr#', - checkedAst: '{\n "as"~string:1~int\n}~map(string, int).as~int', - type: "int", - }, - { - original: { - name: "break", - description: "Check that `break` can be used as a selector.", - expr: "{ 'break': 1 }.break", - value: { int64Value: "1" }, - }, - ast: '{\n "break"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.break^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "break"~string:1~int\n}~map(string, int).break~int', - type: "int", - }, - { - original: { - name: "const", - description: "Check that `const` can be used as a selector.", - expr: "{ 'const': 1 }.const", - value: { int64Value: "1" }, - }, - ast: '{\n "const"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.const^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "const"~string:1~int\n}~map(string, int).const~int', - type: "int", - }, - { - original: { - name: "continue", - description: "Check that `continue` can be used as a selector.", - expr: "{ 'continue': 1 }.continue", - value: { int64Value: "1" }, - }, - ast: '{\n "continue"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.continue^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "continue"~string:1~int\n}~map(string, int).continue~int', - type: "int", - }, - { - original: { - name: "else", - description: "Check that `else` can be used as a selector.", - expr: "{ 'else': 1 }.else", - value: { int64Value: "1" }, - }, - ast: '{\n "else"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.else^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "else"~string:1~int\n}~map(string, int).else~int', - type: "int", - }, - { - original: { - name: "for", - description: "Check that `for` can be used as a selector.", - expr: "{ 'for': 1 }.for", - value: { int64Value: "1" }, - }, - ast: '{\n "for"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.for^#*expr.Expr_SelectExpr#', - checkedAst: '{\n "for"~string:1~int\n}~map(string, int).for~int', - type: "int", - }, - { - original: { - name: "function", - description: "Check that `function` can be used as a selector.", - expr: "{ 'function': 1 }.function", - value: { int64Value: "1" }, - }, - ast: '{\n "function"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.function^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "function"~string:1~int\n}~map(string, int).function~int', - type: "int", - }, - { - original: { - name: "if", - description: "Check that `if` can be used as a selector.", - expr: "{ 'if': 1 }.if", - value: { int64Value: "1" }, - }, - ast: '{\n "if"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.if^#*expr.Expr_SelectExpr#', - checkedAst: '{\n "if"~string:1~int\n}~map(string, int).if~int', - type: "int", - }, - { - original: { - name: "import", - description: "Check that `import` can be used as a selector.", - expr: "{ 'import': 1 }.import", - value: { int64Value: "1" }, - }, - ast: '{\n "import"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.import^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "import"~string:1~int\n}~map(string, int).import~int', - type: "int", - }, - { - original: { - name: "let", - description: "Check that `let` can be used as a selector.", - expr: "{ 'let': 1 }.let", - value: { int64Value: "1" }, - }, - ast: '{\n "let"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.let^#*expr.Expr_SelectExpr#', - checkedAst: '{\n "let"~string:1~int\n}~map(string, int).let~int', - type: "int", - }, - { - original: { - name: "loop", - description: "Check that `loop` can be used as a selector.", - expr: "{ 'loop': 1 }.loop", - value: { int64Value: "1" }, - }, - ast: '{\n "loop"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.loop^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "loop"~string:1~int\n}~map(string, int).loop~int', - type: "int", - }, - { - original: { - name: "package", - description: "Check that `package` can be used as a selector.", - expr: "{ 'package': 1 }.package", - value: { int64Value: "1" }, - }, - ast: '{\n "package"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.package^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "package"~string:1~int\n}~map(string, int).package~int', - type: "int", - }, - { - original: { - name: "namespace", - description: - "Check that `namespace` can be used as a selector.", - expr: "{ 'namespace': 1 }.namespace", - value: { int64Value: "1" }, - }, - ast: '{\n "namespace"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.namespace^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "namespace"~string:1~int\n}~map(string, int).namespace~int', - type: "int", - }, - { - original: { - name: "return", - description: "Check that `return` can be used as a selector.", - expr: "{ 'return': 1 }.return", - value: { int64Value: "1" }, - }, - ast: '{\n "return"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.return^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "return"~string:1~int\n}~map(string, int).return~int', - type: "int", - }, - { - original: { - name: "var", - description: "Check that `var` can be used as a selector.", - expr: "{ 'var': 1 }.var", - value: { int64Value: "1" }, - }, - ast: '{\n "var"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.var^#*expr.Expr_SelectExpr#', - checkedAst: '{\n "var"~string:1~int\n}~map(string, int).var~int', - type: "int", - }, - { - original: { - name: "void", - description: "Check that `void` can be used as a selector.", - expr: "{ 'void': 1 }.void", - value: { int64Value: "1" }, - }, - ast: '{\n "void"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.void^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "void"~string:1~int\n}~map(string, int).void~int', - type: "int", - }, - { - original: { - name: "while", - description: "Check that `while` can be used as a selector.", - expr: "{ 'while': 1 }.while", - value: { int64Value: "1" }, - }, - ast: '{\n "while"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.while^#*expr.Expr_SelectExpr#', - checkedAst: - '{\n "while"~string:1~int\n}~map(string, int).while~int', - type: "int", - }, - ], - }, - { - name: "receiver_function_names", - tests: [ - { - original: { - name: "as", - description: - "Check that `as` can be used as a receiver function.", - expr: "a.as() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.as()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.as() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'as' (in container '')\n | a.as() || true\n | ....^", - }, - { - original: { - name: "break", - description: - "Check that `break` can be used as a receiver function.", - expr: "a.break() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.break()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.break() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'break' (in container '')\n | a.break() || true\n | .......^", - }, - { - original: { - name: "const", - description: - "Check that `const` can be used as a receiver function.", - expr: "a.const() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.const()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.const() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'const' (in container '')\n | a.const() || true\n | .......^", - }, - { - original: { - name: "continue", - description: - "Check that `continue` can be used as a receiver function.", - expr: "a.continue() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.continue()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.continue() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'continue' (in container '')\n | a.continue() || true\n | ..........^", - }, - { - original: { - name: "else", - description: - "Check that `else` can be used as a receiver function.", - expr: "a.else() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.else()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.else() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'else' (in container '')\n | a.else() || true\n | ......^", - }, - { - original: { - name: "for", - description: - "Check that `for` can be used as a receiver function.", - expr: "a.for() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.for()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.for() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'for' (in container '')\n | a.for() || true\n | .....^", - }, - { - original: { - name: "function", - description: - "Check that `function` can be used as a receiver function.", - expr: "a.function() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.function()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.function() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'function' (in container '')\n | a.function() || true\n | ..........^", - }, - { - original: { - name: "if", - description: - "Check that `if` can be used as a receiver function.", - expr: "a.if() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.if()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.if() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'if' (in container '')\n | a.if() || true\n | ....^", - }, - { - original: { - name: "import", - description: - "Check that `import` can be used as a receiver function.", - expr: "a.import() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.import()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.import() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'import' (in container '')\n | a.import() || true\n | ........^", - }, - { - original: { - name: "let", - description: - "Check that `let` can be used as a receiver function.", - expr: "a.let() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.let()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.let() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'let' (in container '')\n | a.let() || true\n | .....^", - }, - { - original: { - name: "loop", - description: - "Check that `loop` can be used as a receiver function.", - expr: "a.loop() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.loop()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.loop() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'loop' (in container '')\n | a.loop() || true\n | ......^", - }, - { - original: { - name: "package", - description: - "Check that `package` can be used as a receiver function.", - expr: "a.package() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.package()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.package() || true\n | ^\nERROR: \u003cinput\u003e:1:10: undeclared reference to 'package' (in container '')\n | a.package() || true\n | .........^", - }, - { - original: { - name: "namespace", - description: - "Check that `namespace` can be used as a receiver function.", - expr: "a.namespace() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.namespace()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.namespace() || true\n | ^\nERROR: \u003cinput\u003e:1:12: undeclared reference to 'namespace' (in container '')\n | a.namespace() || true\n | ...........^", - }, - { - original: { - name: "return", - description: - "Check that `return` can be used as a receiver function.", - expr: "a.return() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.return()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.return() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'return' (in container '')\n | a.return() || true\n | ........^", - }, - { - original: { - name: "var", - description: - "Check that `var` can be used as a receiver function.", - expr: "a.var() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.var()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.var() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'var' (in container '')\n | a.var() || true\n | .....^", - }, - { - original: { - name: "void", - description: - "Check that `void` can be used as a receiver function.", - expr: "a.void() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.void()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.void() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'void' (in container '')\n | a.void() || true\n | ......^", - }, - { - original: { - name: "while", - description: - "Check that `while` can be used as a receiver function.", - expr: "a.while() || true", - disableCheck: true, - value: { boolValue: true }, - }, - ast: "_||_(\n a^#*expr.Expr_IdentExpr#.while()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.while() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'while' (in container '')\n | a.while() || true\n | .......^", - }, - ], - }, - { - name: "struct_field_names", - tests: [ - { - original: { - name: "as", - description: - "Check that `as` can be used as a struct field name.", - expr: "TestAllTypes{ as: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - as: true, - }, - }, - }, - ast: "TestAllTypes{\n as:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n as:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "break", - description: - "Check that `break` can be used as a struct field name.", - expr: "TestAllTypes{ break: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - break: true, - }, - }, - }, - ast: "TestAllTypes{\n break:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n break:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "const", - description: - "Check that `const` can be used as a struct field name.", - expr: "TestAllTypes{ const: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - const: true, - }, - }, - }, - ast: "TestAllTypes{\n const:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n const:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "continue", - description: - "Check that `continue` can be used as a struct field name.", - expr: "TestAllTypes{ continue: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - continue: true, - }, - }, - }, - ast: "TestAllTypes{\n continue:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n continue:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "else", - description: - "Check that `else` can be used as a struct field name.", - expr: "TestAllTypes{ else: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - else: true, - }, - }, - }, - ast: "TestAllTypes{\n else:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n else:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "for", - description: - "Check that `for` can be used as a struct field name.", - expr: "TestAllTypes{ for: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - for: true, - }, - }, - }, - ast: "TestAllTypes{\n for:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n for:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "function", - description: - "Check that `function` can be used as a struct field name.", - expr: "TestAllTypes{ function: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - function: true, - }, - }, - }, - ast: "TestAllTypes{\n function:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n function:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "if", - description: - "Check that `if` can be used as a struct field name.", - expr: "TestAllTypes{ if: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - if: true, - }, - }, - }, - ast: "TestAllTypes{\n if:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n if:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "import", - description: - "Check that `import` can be used as a struct field name.", - expr: "TestAllTypes{ import: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - import: true, - }, - }, - }, - ast: "TestAllTypes{\n import:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n import:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "let", - description: - "Check that `let` can be used as a struct field name.", - expr: "TestAllTypes{ let: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - let: true, - }, - }, - }, - ast: "TestAllTypes{\n let:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n let:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "loop", - description: - "Check that `loop` can be used as a struct field name.", - expr: "TestAllTypes{ loop: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - loop: true, - }, - }, - }, - ast: "TestAllTypes{\n loop:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n loop:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "package", - description: - "Check that `package` can be used as a struct field name.", - expr: "TestAllTypes{ package: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - package: true, - }, - }, - }, - ast: "TestAllTypes{\n package:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n package:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "namespace", - description: - "Check that `namespace` can be used as a struct field name.", - expr: "TestAllTypes{ namespace: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - namespace: true, - }, - }, - }, - ast: "TestAllTypes{\n namespace:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n namespace:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "return", - description: - "Check that `return` can be used as a struct field name.", - expr: "TestAllTypes{ return: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - return: true, - }, - }, - }, - ast: "TestAllTypes{\n return:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n return:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "var", - description: - "Check that `var` can be used as a struct field name.", - expr: "TestAllTypes{ var: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - var: true, - }, - }, - }, - ast: "TestAllTypes{\n var:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n var:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "void", - description: - "Check that `void` can be used as a struct field name.", - expr: "TestAllTypes{ void: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - void: true, - }, - }, - }, - ast: "TestAllTypes{\n void:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n void:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "while", - description: - "Check that `while` can be used as a struct field name.", - expr: "TestAllTypes{ while: true }", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - while: true, - }, - }, - }, - ast: "TestAllTypes{\n while:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n while:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - ], - }, - { - name: "plumbing", - suites: [ - { - name: "min", - tests: [ - { - original: { - name: "min_program", - description: "Smallest functionality: expr in, result out.", - expr: "17", - value: { int64Value: "17" }, - }, - ast: "17^#*expr.Constant_Int64Value#", - checkedAst: "17~int", - type: "int", - }, - ], - }, - { - name: "eval_results", - tests: [ - { - original: { - name: "error_result", - description: "Check that error results go through.", - expr: "1 / 0", - evalError: { errors: [{ message: "foo" }] }, - }, - ast: "_/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: "_/_(\n 1~int,\n 0~int\n)~int^divide_int64", - type: "int", - }, - { - original: { - name: "eval_map_results", - description: - "Check that map literals results are order independent.", - expr: '{"k1":"v1","k":"v"}', - value: { - mapValue: { - entries: [ - { - key: { stringValue: "k" }, - value: { stringValue: "v" }, - }, - { - key: { stringValue: "k1" }, - value: { stringValue: "v1" }, - }, - ], - }, - }, - }, - ast: '{\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - '{\n "k1"~string:"v1"~string,\n "k"~string:"v"~string\n}~map(string, string)', - type: "map(string, string)", - }, - ], - }, - { - name: "check_inputs", - tests: [ - { - original: { - name: "skip_check", - description: "Make sure we can skip type checking.", - expr: "[17, 'pancakes']", - disableCheck: true, - value: { - listValue: { - values: [{ int64Value: "17" }, { stringValue: "pancakes" }], - }, - }, - }, - ast: '[\n 17^#*expr.Constant_Int64Value#,\n "pancakes"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#', - checkedAst: '[\n 17~int,\n "pancakes"~string\n]~list(dyn)', - type: "list(dyn)", - }, - ], - }, - { - name: "eval_inputs", - tests: [ - { - original: { - name: "one_ignored_value_arg", - description: - "Check that value bindings can be given, even if ignored.", - expr: "'foo'", - bindings: { x: { value: { int64Value: "17" } } }, - value: { stringValue: "foo" }, - }, - ast: '"foo"^#*expr.Constant_StringValue#', - checkedAst: '"foo"~string', - type: "string", - }, - ], - }, - ], - }, - { - name: "proto2", - suites: [ - { - name: "literal_singular", - tests: [ - { - original: { - name: "int64_nocontainer", - expr: "cel.expr.conformance.proto2.TestAllTypes{single_int64: 17}", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt64: "17", - }, - }, - }, - ast: "cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "int32", - expr: "TestAllTypes{single_int32: -34}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: -34, - }, - }, - }, - ast: "TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "int32_eq_uint", - expr: "Int32Value{value: 34} == dyn(UInt64Value{value: 34u})", - container: "google.protobuf", - value: { boolValue: true }, - }, - ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_int32_eq_uint", - expr: "Int32Value{value: 34} == dyn(UInt64Value{value: 18446744073709551615u})", - container: "google.protobuf", - value: { boolValue: false }, - }, - ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "int32_eq_double", - expr: "Int32Value{value: 34} == dyn(DoubleValue{value: 34.0})", - container: "google.protobuf", - value: { boolValue: true }, - }, - ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_int32_eq_double", - expr: "Int32Value{value: 34} == dyn(DoubleValue{value: -9223372036854775809.0})", - container: "google.protobuf", - value: { boolValue: false }, - }, - ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:-9.223372036854776e+18^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:-9.223372036854776e+18~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "int64", - expr: "TestAllTypes{single_int64: 17}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt64: "17", - }, - }, - }, - ast: "TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "uint32", - expr: "TestAllTypes{single_uint32: 1u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint32: 1, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "uint32_eq_int", - expr: "UInt32Value{value: 34u} == dyn(Int64Value{value: 34})", - container: "google.protobuf", - value: { boolValue: true }, - }, - ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_uint32_eq_int", - expr: "UInt32Value{value: 34u} == dyn(Int64Value{value: -1})", - container: "google.protobuf", - value: { boolValue: false }, - }, - ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "uint32_eq_double", - expr: "UInt32Value{value: 34u} == dyn(DoubleValue{value: 34.0})", - container: "google.protobuf", - value: { boolValue: true }, - }, - ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_uint32_eq_double", - expr: "UInt32Value{value: 34u} == dyn(DoubleValue{value: 18446744073709551616.0})", - container: "google.protobuf", - value: { boolValue: false }, - }, - ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:1.8446744073709552e+19^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:1.8446744073709552e+19~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "uint64", - expr: "TestAllTypes{single_uint64: 9999u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint64: "9999", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "sint32", - expr: "TestAllTypes{single_sint32: -3}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleSint32: -3, - }, - }, - }, - ast: "TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "sint64", - expr: "TestAllTypes{single_sint64: 255}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleSint64: "255", - }, - }, - }, - ast: "TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "fixed32", - expr: "TestAllTypes{single_fixed32: 43u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFixed32: 43, - }, - }, - }, - ast: "TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "fixed64", - expr: "TestAllTypes{single_fixed64: 1880u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFixed64: "1880", - }, - }, - }, - ast: "TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "sfixed32", - expr: "TestAllTypes{single_sfixed32: -404}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleSfixed32: -404, - }, - }, - }, - ast: "TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "sfixed64", - expr: "TestAllTypes{single_sfixed64: -1}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleSfixed64: "-1", - }, - }, - }, - ast: "TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "float", - expr: "TestAllTypes{single_float: 3.1416}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloat: 3.1416, - }, - }, - }, - ast: "TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "float_eq_int", - expr: "FloatValue{value: 3.0} == dyn(Int64Value{value: 3})", - container: "google.protobuf", - value: { boolValue: true }, - }, - ast: "_==_(\n FloatValue{\n value:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{\n value:3~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:3~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_float_eq_int", - expr: "FloatValue{value: -1.14} == dyn(Int64Value{value: -1})", - container: "google.protobuf", - value: { boolValue: false }, - }, - ast: "_==_(\n FloatValue{\n value:-1.14^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{\n value:-1.14~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "float_eq_uint", - expr: "FloatValue{value: 34.0} == dyn(UInt64Value{value: 34u})", - container: "google.protobuf", - value: { boolValue: true }, - }, - ast: "_==_(\n FloatValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{\n value:34~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "not_float_eq_uint", - expr: "FloatValue{value: -1.0} == dyn(UInt64Value{value: 18446744073709551615u})", - container: "google.protobuf", - value: { boolValue: false }, - }, - ast: "_==_(\n FloatValue{\n value:-1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n google.protobuf.FloatValue{\n value:-1~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "double", - expr: "TestAllTypes{single_double: 6.022e23}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleDouble: 6.022e23, - }, - }, - }, - ast: "TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "bool", - expr: "TestAllTypes{single_bool: true}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBool: true, - }, - }, - }, - ast: "TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "string", - expr: "TestAllTypes{single_string: 'foo'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleString: "foo", - }, - }, - }, - ast: 'TestAllTypes{\n single_string:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_string:"foo"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "bytes", - expr: "TestAllTypes{single_bytes: b'\\377'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBytes: "/w==", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes:b"\\xff"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes:b"\\xff"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - ], - }, - { - name: "literal_wellknown", - tests: [ - { - original: { - name: "any", - expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 1}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleAny: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 1, - }, - }, - }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "duration", - expr: "TestAllTypes{single_duration: duration('123s')}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleDuration: "123s", - }, - }, - }, - ast: 'TestAllTypes{\n single_duration:duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_duration:duration(\n "123s"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "timestamp", - expr: "TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleTimestamp: "2009-02-13T23:31:30Z", - }, - }, - }, - ast: 'TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "struct", - expr: "TestAllTypes{single_struct: {'one': 1, 'two': 2}}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleStruct: { one: 1, two: 2 }, - }, - }, - }, - ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n "one"~string:1~int,\n "two"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "value", - expr: "TestAllTypes{single_value: 'foo'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleValue: "foo", - }, - }, - }, - ast: 'TestAllTypes{\n single_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:"foo"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "int64_wrapper", - expr: "TestAllTypes{single_int64_wrapper: -321}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt64Wrapper: "-321", - }, - }, - }, - ast: "TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "int32_wrapper", - expr: "TestAllTypes{single_int32_wrapper: -456}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32Wrapper: -456, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "double_wrapper", - expr: "TestAllTypes{single_double_wrapper: 2.71828}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleDoubleWrapper: 2.71828, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "float_wrapper", - expr: "TestAllTypes{single_float_wrapper: 2.99792e8}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleFloatWrapper: 299792000, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "uint64_wrapper", - expr: "TestAllTypes{single_uint64_wrapper: 8675309u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint64Wrapper: "8675309", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "uint32_wrapper", - expr: "TestAllTypes{single_uint32_wrapper: 987u}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleUint32Wrapper: 987, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "string_wrapper", - expr: "TestAllTypes{single_string_wrapper: 'hubba'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleStringWrapper: "hubba", - }, - }, - }, - ast: 'TestAllTypes{\n single_string_wrapper:"hubba"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:"hubba"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "bool_wrapper", - expr: "TestAllTypes{single_bool_wrapper: true}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBoolWrapper: true, - }, - }, - }, - ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - { - original: { - name: "bytes_wrapper", - expr: "TestAllTypes{single_bytes_wrapper: b'\\301\\103'}", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleBytesWrapper: "wUM=", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', - type: "cel.expr.conformance.proto2.TestAllTypes", - }, - ], - }, - { - name: "singular_bind", - tests: [ - { - original: { - name: "int32", - expr: "x.single_int32", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt32: 17, - }, - }, - }, - }, - value: { int64Value: "17" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto2.TestAllTypes^x.single_int32~int", - type: "int", - }, - { - original: { - name: "int64", - expr: "x.single_int64", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - singleInt64: "-99", - }, - }, - }, - }, - value: { int64Value: "-99" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto2.TestAllTypes^x.single_int64~int", - type: "int", - }, - ], - }, - { - name: "empty_field", - tests: [ - { - original: { - name: "scalar_with_default", - expr: "TestAllTypes{}.single_int32", - container: "cel.expr.conformance.proto2", - value: { int64Value: "-32" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~int", - type: "int", - }, - { - original: { - name: "scalar_no_default", - expr: "TestAllTypes{}.single_fixed32", - container: "cel.expr.conformance.proto2", - value: { uint64Value: "0" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_fixed32~uint", - type: "uint", - }, - { - original: { - name: "nested_message", - expr: "TestAllTypes{}.single_nested_message", - container: "cel.expr.conformance.proto2", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes.NestedMessage", - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage", - type: "cel.expr.conformance.proto2.TestAllTypes.NestedMessage", - }, - { - original: { - name: "nested_message_subfield", - expr: "TestAllTypes{}.single_nested_message.bb", - container: "cel.expr.conformance.proto2", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage.bb~int", - type: "int", - }, - { - original: { - name: "wkt", - expr: "TestAllTypes{}.single_int64_wrapper", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "repeated_scalar", - expr: "TestAllTypes{}.repeated_int64", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int64~list(int)", - type: "list(int)", - }, - { - original: { - name: "repeated_enum", - expr: "TestAllTypes{}.repeated_nested_enum", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)", - type: "list(int)", - }, - { - original: { - name: "repeated_nested", - expr: "TestAllTypes{}.repeated_nested_message", - container: "cel.expr.conformance.proto2", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)", - type: "list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)", - }, - { - original: { - name: "map", - expr: "TestAllTypes{}.map_string_string", - container: "cel.expr.conformance.proto2", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~map(string, string)", - type: "map(string, string)", - }, - ], - }, - { - name: "has", - tests: [ - { - original: { - name: "undefined", - expr: "has(TestAllTypes{}.no_such_field)", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "no_such_field" }] }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^", - }, - { - original: { - name: "repeated_none_implicit", - expr: "has(TestAllTypes{}.repeated_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "repeated_none_explicit", - expr: "has(TestAllTypes{repeated_int32: []}.repeated_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "repeated_one", - expr: "has(TestAllTypes{repeated_int32: [1]}.repeated_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "repeated_many", - expr: "has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "map_none_implicit", - expr: "has(TestAllTypes{}.map_string_string)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool", - type: "bool", - }, - { - original: { - name: "map_none_explicit", - expr: "has(TestAllTypes{map_string_string: {}}.map_string_string)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool", - type: "bool", - }, - { - original: { - name: "map_one_default", - expr: "has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: 'TestAllTypes{\n map_string_string:{\n "MT"^#*expr.Constant_StringValue#:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n "MT"~string:""~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool', - type: "bool", - }, - { - original: { - name: "map_one", - expr: "has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool', - type: "bool", - }, - { - original: { - name: "map_many", - expr: "has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:"dos"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string,\n "two"~string:"dos"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool', - type: "bool", - }, - { - original: { - name: "required", - expr: "has(TestRequired{required_int32: 4}.required_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestRequired{\n required_int32:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.required_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestRequired{\n required_int32:4~int\n}~cel.expr.conformance.proto2.TestRequired^cel.expr.conformance.proto2.TestRequired.required_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_unset_no_default", - expr: "has(TestAllTypes{}.single_sint32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_set_no_default", - expr: "has(TestAllTypes{single_sint32: -4}.single_sint32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_sint32:-4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-4~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_unset_with_default", - expr: "has(TestAllTypes{}.single_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_set_with_default", - expr: "has(TestAllTypes{single_int32: 16}.single_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_set_to_default", - expr: "has(TestAllTypes{single_int32: -32}.single_int32)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_int32:-32^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-32~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_message_unset", - expr: "has(TestAllTypes{}.standalone_message)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_message_set", - expr: "has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_enum_unset", - expr: "has(TestAllTypes{}.standalone_enum)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_enum_set", - expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool", - type: "bool", - }, - { - original: { - name: "optional_enum_set_zero", - expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_unset", - expr: "has(TestAllTypes{}.single_nested_message)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_other_set", - expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_set", - expr: "has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_set_default", - expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_enum~test-only~~bool", - type: "bool", - }, - ], - }, - { - name: "set_null", - tests: [ - { - original: { - name: "single_message", - expr: "TestAllTypes{single_nested_message: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "single_any", - expr: "TestAllTypes{single_any: null}.single_any", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "single_value", - expr: "TestAllTypes{single_value: null}.single_value", - container: "cel.expr.conformance.proto2", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "single_duration", - expr: "TestAllTypes{single_duration: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "single_timestamp", - expr: "TestAllTypes{single_timestamp: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "single_scalar", - expr: "TestAllTypes{single_bool: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^", - }, - { - original: { - name: "repeated", - expr: "TestAllTypes{repeated_int32: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^", - }, - { - original: { - name: "map", - expr: "TestAllTypes{map_string_string: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^", - }, - { - original: { - name: "list_value", - expr: "TestAllTypes{list_value: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^", - }, - { - original: { - name: "single_struct", - expr: "TestAllTypes{single_struct: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto2", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^", - }, - ], - }, - { - name: "quoted_fields", - tests: [ - { - original: { - name: "set_field_with_quoted_name", - expr: "TestAllTypes{`in`: true} == TestAllTypes{}", - container: "cel.expr.conformance.proto2", - value: { boolValue: false }, - }, - error: - "ERROR: set_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^", - }, - { - original: { - name: "get_field_with_quoted_name", - expr: "TestAllTypes{`in`: true}.`in`", - container: "cel.expr.conformance.proto2", - value: { boolValue: true }, - }, - error: - "ERROR: get_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field_with_quoted_name:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^", - }, - ], - }, - { - name: "extensions_has", - tests: [ - { - original: { - name: "package_scoped_int32", - expr: "has(msg.`cel.expr.conformance.proto2.int32_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.int32_ext]": 42, - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_int32:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.int32_ext`)\n | ........^", - }, - { - original: { - name: "package_scoped_nested_ext", - expr: "has(msg.`cel.expr.conformance.proto2.nested_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_ext]": {}, - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_ext`)\n | ........^", - }, - { - original: { - name: "package_scoped_test_all_types_ext", - expr: "has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.test_all_types_ext]": {}, - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_test_all_types_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)\n | ........^", - }, - { - original: { - name: "package_scoped_test_all_types_nested_enum_ext", - expr: "has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_test_all_types_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)\n | ........^", - }, - { - original: { - name: "package_scoped_repeated_test_all_types", - expr: "has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)\n | ........^", - }, - { - original: { - name: "message_scoped_int64", - expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": - "42", - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_int64:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)\n | ........^", - }, - { - original: { - name: "message_scoped_nested_ext", - expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": - {}, - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)\n | ........^", - }, - { - original: { - name: "message_scoped_nested_enum_ext", - expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": - "BAR", - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)\n | ........^", - }, - { - original: { - name: "message_scoped_repeated_test_all_types", - expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)\n | ........^", - }, - ], - }, - { - name: "extensions_get", - tests: [ - { - original: { - name: "package_scoped_int32", - expr: "msg.`cel.expr.conformance.proto2.int32_ext` == 42", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.int32_ext]": 42, - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_int32:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.int32_ext` == 42\n | ....^", - }, - { - original: { - name: "package_scoped_nested_ext", - expr: "msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_ext]": {}, - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^", - }, - { - original: { - name: "package_scoped_test_all_types_ext", - expr: "msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.test_all_types_ext]": {}, - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_test_all_types_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^", - }, - { - original: { - name: "package_scoped_test_all_types_nested_enum_ext", - expr: "msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_test_all_types_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^", - }, - { - original: { - name: "package_scoped_repeated_test_all_types", - expr: "msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - error: - "ERROR: package_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^", - }, - { - original: { - name: "message_scoped_int64", - expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": - "42", - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_int64:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42\n | ....^", - }, - { - original: { - name: "message_scoped_nested_ext", - expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": - {}, - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^", - }, - { - original: { - name: "message_scoped_nested_enum_ext", - expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": - "BAR", - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^", - }, - { - original: { - name: "message_scoped_repeated_test_all_types", - expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - error: - "ERROR: message_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^", - }, - ], - }, - ], - }, - { - name: "proto2_ext", - suites: [ - { - name: "has_ext", - tests: [ - { - original: { - name: "package_scoped_int32", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.int32_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.int32_ext]": 42, - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "package_scoped_nested_ext", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.nested_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_ext]": {}, - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "package_scoped_test_all_types_ext", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.test_all_types_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.test_all_types_ext]": {}, - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "package_scoped_test_all_types_nested_enum_ext", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.nested_enum_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "package_scoped_repeated_test_all_types", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.repeated_test_all_types)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~test-only~~bool", - type: "bool", - }, - { - original: { - name: "message_scoped_int64", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": - "42", - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "message_scoped_nested_ext", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": - {}, - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "message_scoped_nested_enum_ext", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": - "BAR", - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~test-only~~bool", - type: "bool", - }, - { - original: { - name: "message_scoped_repeated_test_all_types", - expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types)", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~test-only~~bool", - type: "bool", - }, - ], - }, - { - name: "get_ext", - tests: [ - { - original: { - name: "package_scoped_int32", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.int32_ext) == 42", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.int32_ext]": 42, - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~int,\n 42~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "package_scoped_nested_ext", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_ext]": {}, - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "package_scoped_test_all_types_ext", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.test_all_types_ext) == cel.expr.conformance.proto2.TestAllTypes{}", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.test_all_types_ext]": {}, - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "package_scoped_test_all_types_nested_enum_ext", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "package_scoped_repeated_test_all_types", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "message_scoped_int64", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext) == 42", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": - "42", - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~int,\n 42~int\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "message_scoped_nested_ext", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": - {}, - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "message_scoped_nested_enum_ext", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": - "BAR", - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "message_scoped_repeated_test_all_types", - expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto2.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", - "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": - [{ singleInt64: "1" }, { singleBool: true }], - }, - }, - }, - }, - }, - ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals", - type: "bool", - }, - ], - }, - ], - }, - { - name: "proto3", - suites: [ - { - name: "literal_singular", - tests: [ - { - original: { - name: "int64_nocontainer", - expr: "cel.expr.conformance.proto3.TestAllTypes{single_int64: 17}", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64: "17", - }, - }, - }, - ast: "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "int32", - expr: "TestAllTypes{single_int32: -34}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: -34, - }, - }, - }, - ast: "TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "int64", - expr: "TestAllTypes{single_int64: 17}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64: "17", - }, - }, - }, - ast: "TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "uint32", - expr: "TestAllTypes{single_uint32: 1u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint32: 1, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "uint64", - expr: "TestAllTypes{single_uint64: 9999u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint64: "9999", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "sint32", - expr: "TestAllTypes{single_sint32: -3}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleSint32: -3, - }, - }, - }, - ast: "TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "sint64", - expr: "TestAllTypes{single_sint64: 255}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleSint64: "255", - }, - }, - }, - ast: "TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "fixed32", - expr: "TestAllTypes{single_fixed32: 43u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFixed32: 43, - }, - }, - }, - ast: "TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "fixed64", - expr: "TestAllTypes{single_fixed64: 1880u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFixed64: "1880", - }, - }, - }, - ast: "TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "sfixed32", - expr: "TestAllTypes{single_sfixed32: -404}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleSfixed32: -404, - }, - }, - }, - ast: "TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "sfixed64", - expr: "TestAllTypes{single_sfixed64: -1}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleSfixed64: "-1", - }, - }, - }, - ast: "TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "float", - expr: "TestAllTypes{single_float: 3.1416}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFloat: 3.1416, - }, - }, - }, - ast: "TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "double", - expr: "TestAllTypes{single_double: 6.022e23}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleDouble: 6.022e23, - }, - }, - }, - ast: "TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "bool", - expr: "TestAllTypes{single_bool: true}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBool: true, - }, - }, - }, - ast: "TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "string", - expr: "TestAllTypes{single_string: 'foo'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleString: "foo", - }, - }, - }, - ast: 'TestAllTypes{\n single_string:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_string:"foo"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "bytes", - expr: "TestAllTypes{single_bytes: b'\\377'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBytes: "/w==", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes:b"\\xff"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes:b"\\xff"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "literal_wellknown", - tests: [ - { - original: { - name: "any", - expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 1}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleAny: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 1, - }, - }, - }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "duration", - expr: "TestAllTypes{single_duration: duration('123s')}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleDuration: "123s", - }, - }, - }, - ast: 'TestAllTypes{\n single_duration:duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_duration:duration(\n "123s"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "timestamp", - expr: "TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleTimestamp: "2009-02-13T23:31:30Z", - }, - }, - }, - ast: 'TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "struct", - expr: "TestAllTypes{single_struct: {'one': 1, 'two': 2}}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleStruct: { one: 1, two: 2 }, - }, - }, - }, - ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n "one"~string:1~int,\n "two"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "value", - expr: "TestAllTypes{single_value: 'foo'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleValue: "foo", - }, - }, - }, - ast: 'TestAllTypes{\n single_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:"foo"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "int64_wrapper", - expr: "TestAllTypes{single_int64_wrapper: -321}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64Wrapper: "-321", - }, - }, - }, - ast: "TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "int32_wrapper", - expr: "TestAllTypes{single_int32_wrapper: -456}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32Wrapper: -456, - }, - }, - }, - ast: "TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "double_wrapper", - expr: "TestAllTypes{single_double_wrapper: 2.71828}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleDoubleWrapper: 2.71828, - }, - }, - }, - ast: "TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "float_wrapper", - expr: "TestAllTypes{single_float_wrapper: 2.99792e8}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleFloatWrapper: 299792000, - }, - }, - }, - ast: "TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "uint64_wrapper", - expr: "TestAllTypes{single_uint64_wrapper: 8675309u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint64Wrapper: "8675309", - }, - }, - }, - ast: "TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "uint32_wrapper", - expr: "TestAllTypes{single_uint32_wrapper: 987u}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleUint32Wrapper: 987, - }, - }, - }, - ast: "TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "string_wrapper", - expr: "TestAllTypes{single_string_wrapper: 'hubba'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleStringWrapper: "hubba", - }, - }, - }, - ast: 'TestAllTypes{\n single_string_wrapper:"hubba"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:"hubba"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "bool_wrapper", - expr: "TestAllTypes{single_bool_wrapper: true}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBoolWrapper: true, - }, - }, - }, - ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - { - original: { - name: "bytes_wrapper", - expr: "TestAllTypes{single_bytes_wrapper: b'\\301\\103'}", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleBytesWrapper: "wUM=", - }, - }, - }, - ast: 'TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "singular_bind", - tests: [ - { - original: { - name: "int32", - expr: "x.single_int32", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt32: 17, - }, - }, - }, - }, - value: { int64Value: "17" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32~int", - type: "int", - }, - { - original: { - name: "int64", - expr: "x.single_int64", - typeEnv: [ - { - name: "x", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64: "-99", - }, - }, - }, - }, - value: { int64Value: "-99" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64~int", - type: "int", - }, - ], - }, - { - name: "empty_field", - tests: [ - { - original: { - name: "scalar", - expr: "TestAllTypes{}.single_fixed32", - container: "cel.expr.conformance.proto3", - value: { uint64Value: "0" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_fixed32~uint", - type: "uint", - }, - { - original: { - name: "nested_message", - expr: "TestAllTypes{}.single_nested_message", - container: "cel.expr.conformance.proto3", - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage", - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage", - type: "cel.expr.conformance.proto3.TestAllTypes.NestedMessage", - }, - { - original: { - name: "nested_message_subfield", - expr: "TestAllTypes{}.single_nested_message.bb", - container: "cel.expr.conformance.proto3", - value: { int64Value: "0" }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage.bb~int", - type: "int", - }, - { - original: { - name: "wkt", - expr: "TestAllTypes{}.single_int64_wrapper", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int)", - type: "wrapper(int)", - }, - { - original: { - name: "repeated_scalar", - expr: "TestAllTypes{}.repeated_int64", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)", - type: "list(int)", - }, - { - original: { - name: "repeated_enum", - expr: "TestAllTypes{}.repeated_nested_enum", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)", - type: "list(int)", - }, - { - original: { - name: "repeated_nested", - expr: "TestAllTypes{}.repeated_nested_message", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)", - type: "list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)", - }, - { - original: { - name: "map", - expr: "TestAllTypes{}.map_string_string", - container: "cel.expr.conformance.proto3", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~map(string, string)", - type: "map(string, string)", - }, - ], - }, - { - name: "has", - tests: [ - { - original: { - name: "undefined", - expr: "has(TestAllTypes{}.no_such_field)", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "no_such_field" }] }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#", - error: - "ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^", - }, - { - original: { - name: "repeated_none_implicit", - expr: "has(TestAllTypes{}.repeated_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "repeated_none_explicit", - expr: "has(TestAllTypes{repeated_int32: []}.repeated_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "repeated_one", - expr: "has(TestAllTypes{repeated_int32: [1]}.repeated_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "repeated_many", - expr: "has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "map_none_implicit", - expr: "has(TestAllTypes{}.map_string_string)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool", - type: "bool", - }, - { - original: { - name: "map_none_explicit", - expr: "has(TestAllTypes{map_string_string: {}}.map_string_string)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool", - type: "bool", - }, - { - original: { - name: "map_one_default", - expr: "has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: 'TestAllTypes{\n map_string_string:{\n "MT"^#*expr.Constant_StringValue#:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n "MT"~string:""~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool', - type: "bool", - }, - { - original: { - name: "map_one", - expr: "has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool', - type: "bool", - }, - { - original: { - name: "map_many", - expr: "has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:"dos"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string,\n "two"~string:"dos"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool', - type: "bool", - }, - { - original: { - name: "single_unset", - expr: "has(TestAllTypes{}.single_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_set", - expr: "has(TestAllTypes{single_int32: 16}.single_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_set_to_default", - expr: "has(TestAllTypes{single_int32: 0}.single_int32)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n single_int32:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int32:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_message_unset", - expr: "has(TestAllTypes{}.standalone_message)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_message_set", - expr: "has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{bb: 123}}.standalone_message)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{\n bb:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{\n bb:123~int\n }~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_message_set_to_default", - expr: "has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_enum_unset", - expr: "has(TestAllTypes{}.standalone_enum)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_enum_set", - expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool", - type: "bool", - }, - { - original: { - name: "single_enum_set_zero", - expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_unset", - expr: "has(TestAllTypes{}.single_nested_message)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_other_set", - expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_set", - expr: "has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool", - type: "bool", - }, - { - original: { - name: "oneof_set_default", - expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_enum~test-only~~bool", - type: "bool", - }, - ], - }, - { - name: "set_null", - tests: [ - { - original: { - name: "single_message", - expr: "TestAllTypes{single_nested_message: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "single_any", - expr: "TestAllTypes{single_any: null}.single_any", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "single_value", - expr: "TestAllTypes{single_value: null}.single_value", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "single_duration", - expr: "TestAllTypes{single_duration: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "single_timestamp", - expr: "TestAllTypes{single_timestamp: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "single_scalar", - expr: "TestAllTypes{single_bool: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^", - }, - { - original: { - name: "repeated", - expr: "TestAllTypes{repeated_int32: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^", - }, - { - original: { - name: "map", - expr: "TestAllTypes{map_string_string: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^", - }, - { - original: { - name: "list_value", - expr: "TestAllTypes{list_value: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^", - }, - { - original: { - name: "single_struct", - expr: "TestAllTypes{single_struct: null} == TestAllTypes{}", - disableCheck: true, - container: "cel.expr.conformance.proto3", - evalError: { errors: [{ message: "unsupported field type" }] }, - }, - ast: "_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - error: - "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^", - }, - ], - }, - { - name: "quoted_fields", - tests: [ - { - original: { - name: "set_field", - expr: "TestAllTypes{`in`: true} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: false }, - }, - error: - "ERROR: set_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^", - }, - { - original: { - name: "get_field", - expr: "TestAllTypes{`in`: true}.`in`", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - error: - "ERROR: get_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^", - }, - ], - }, - ], - }, - { - name: "string", - suites: [ - { - name: "size", - tests: [ - { - original: { - name: "empty", - expr: "size('')", - value: { int64Value: "0" }, - }, - ast: 'size(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n ""~string\n)~int^size_string', - type: "int", - }, - { - original: { - name: "one_ascii", - expr: "size('A')", - value: { int64Value: "1" }, - }, - ast: 'size(\n "A"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n "A"~string\n)~int^size_string', - type: "int", - }, - { - original: { - name: "one_unicode", - expr: "size('ÿ')", - value: { int64Value: "1" }, - }, - ast: 'size(\n "ÿ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n "ÿ"~string\n)~int^size_string', - type: "int", - }, - { - original: { - name: "ascii", - expr: "size('four')", - value: { int64Value: "4" }, - }, - ast: 'size(\n "four"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n "four"~string\n)~int^size_string', - type: "int", - }, - { - original: { - name: "unicode", - expr: "size('πέντε')", - value: { int64Value: "5" }, - }, - ast: 'size(\n "πέντε"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n "πέντε"~string\n)~int^size_string', - type: "int", - }, - { - original: { - name: "bytes_empty", - expr: "size(b'')", - value: { int64Value: "0" }, - }, - ast: 'size(\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n b""~bytes\n)~int^size_bytes', - type: "int", - }, - { - original: { - name: "bytes", - expr: "size(b'abc')", - value: { int64Value: "3" }, - }, - ast: 'size(\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'size(\n b"abc"~bytes\n)~int^size_bytes', - type: "int", - }, - ], - }, - { - name: "starts_with", - tests: [ - { - original: { - name: "basic_true", - expr: "'foobar'.startsWith('foo')", - value: { boolValue: true }, - }, - ast: '"foobar"^#*expr.Constant_StringValue#.startsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"foobar"~string.startsWith(\n "foo"~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "basic_false", - expr: "'foobar'.startsWith('bar')", - value: { boolValue: false }, - }, - ast: '"foobar"^#*expr.Constant_StringValue#.startsWith(\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"foobar"~string.startsWith(\n "bar"~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "empty_target", - expr: "''.startsWith('foo')", - value: { boolValue: false }, - }, - ast: '""^#*expr.Constant_StringValue#.startsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.startsWith(\n "foo"~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "empty_arg", - expr: "'foobar'.startsWith('')", - value: { boolValue: true }, - }, - ast: '"foobar"^#*expr.Constant_StringValue#.startsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"foobar"~string.startsWith(\n ""~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "empty_empty", - expr: "''.startsWith('')", - value: { boolValue: true }, - }, - ast: '""^#*expr.Constant_StringValue#.startsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.startsWith(\n ""~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "unicode", - expr: "'завтра'.startsWith('за')", - value: { boolValue: true }, - }, - ast: '"завтра"^#*expr.Constant_StringValue#.startsWith(\n "за"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"завтра"~string.startsWith(\n "за"~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "unicode_smp", - expr: "'🐱😀😛'.startsWith('🐱')", - value: { boolValue: true }, - }, - ast: '"🐱😀😛"^#*expr.Constant_StringValue#.startsWith(\n "🐱"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"🐱😀😛"~string.startsWith(\n "🐱"~string\n)~bool^starts_with_string', - type: "bool", - }, - ], - }, - { - name: "ends_with", - tests: [ - { - original: { - name: "basic_true", - expr: "'foobar'.endsWith('bar')", - value: { boolValue: true }, - }, - ast: '"foobar"^#*expr.Constant_StringValue#.endsWith(\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"foobar"~string.endsWith(\n "bar"~string\n)~bool^ends_with_string', - type: "bool", - }, - { - original: { - name: "basic_false", - expr: "'foobar'.endsWith('foo')", - value: { boolValue: false }, - }, - ast: '"foobar"^#*expr.Constant_StringValue#.endsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"foobar"~string.endsWith(\n "foo"~string\n)~bool^ends_with_string', - type: "bool", - }, - { - original: { - name: "empty_target", - expr: "''.endsWith('foo')", - value: { boolValue: false }, - }, - ast: '""^#*expr.Constant_StringValue#.endsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.endsWith(\n "foo"~string\n)~bool^ends_with_string', - type: "bool", - }, - { - original: { - name: "empty_arg", - expr: "'foobar'.endsWith('')", - value: { boolValue: true }, - }, - ast: '"foobar"^#*expr.Constant_StringValue#.endsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"foobar"~string.endsWith(\n ""~string\n)~bool^ends_with_string', - type: "bool", - }, - { - original: { - name: "empty_empty", - expr: "''.endsWith('')", - value: { boolValue: true }, - }, - ast: '""^#*expr.Constant_StringValue#.endsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.endsWith(\n ""~string\n)~bool^ends_with_string', - type: "bool", - }, - { - original: { - name: "unicode", - expr: "'forté'.endsWith('té')", - value: { boolValue: true }, - }, - ast: '"forté"^#*expr.Constant_StringValue#.endsWith(\n "té"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"forté"~string.endsWith(\n "té"~string\n)~bool^ends_with_string', - type: "bool", - }, - { - original: { - name: "unicode_smp", - expr: "'🐱😀😛'.endsWith('😛')", - value: { boolValue: true }, - }, - ast: '"🐱😀😛"^#*expr.Constant_StringValue#.endsWith(\n "😛"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"🐱😀😛"~string.endsWith(\n "😛"~string\n)~bool^ends_with_string', - type: "bool", - }, - ], - }, - { - name: "matches", - tests: [ - { - original: { - name: "basic", - expr: "'hubba'.matches('ubb')", - value: { boolValue: true }, - }, - ast: '"hubba"^#*expr.Constant_StringValue#.matches(\n "ubb"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"hubba"~string.matches(\n "ubb"~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "empty_target", - expr: "''.matches('foo|bar')", - value: { boolValue: false }, - }, - ast: '""^#*expr.Constant_StringValue#.matches(\n "foo|bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.matches(\n "foo|bar"~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "empty_arg", - expr: "'cows'.matches('')", - value: { boolValue: true }, - }, - ast: '"cows"^#*expr.Constant_StringValue#.matches(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"cows"~string.matches(\n ""~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "empty_empty", - expr: "''.matches('')", - value: { boolValue: true }, - }, - ast: '""^#*expr.Constant_StringValue#.matches(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.matches(\n ""~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "re_concat", - expr: "'abcd'.matches('bc')", - value: { boolValue: true }, - }, - ast: '"abcd"^#*expr.Constant_StringValue#.matches(\n "bc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"abcd"~string.matches(\n "bc"~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "re_alt", - expr: "'grey'.matches('gr(a|e)y')", - value: { boolValue: true }, - }, - ast: '"grey"^#*expr.Constant_StringValue#.matches(\n "gr(a|e)y"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"grey"~string.matches(\n "gr(a|e)y"~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "re_rep", - expr: "'banana'.matches('ba(na)*')", - value: { boolValue: true }, - }, - ast: '"banana"^#*expr.Constant_StringValue#.matches(\n "ba(na)*"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"banana"~string.matches(\n "ba(na)*"~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "unicode", - expr: "'mañana'.matches('a+ñ+a+')", - value: { boolValue: true }, - }, - ast: '"mañana"^#*expr.Constant_StringValue#.matches(\n "a+ñ+a+"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"mañana"~string.matches(\n "a+ñ+a+"~string\n)~bool^matches_string', - type: "bool", - }, - { - original: { - name: "unicode_smp", - expr: "'🐱😀😀'.matches('(a|😀){2}')", - value: { boolValue: true }, - }, - ast: '"🐱😀😀"^#*expr.Constant_StringValue#.matches(\n "(a|😀){2}"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"🐱😀😀"~string.matches(\n "(a|😀){2}"~string\n)~bool^matches_string', - type: "bool", - }, - ], - }, - { - name: "concatenation", - tests: [ - { - original: { - name: "concat_true", - expr: "'he' + 'llo'", - value: { stringValue: "hello" }, - }, - ast: '_+_(\n "he"^#*expr.Constant_StringValue#,\n "llo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n "he"~string,\n "llo"~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "concat_with_spaces", - expr: "'hello' + ' ' == 'hello'", - value: { boolValue: false }, - }, - ast: '_==_(\n _+_(\n "hello"^#*expr.Constant_StringValue#,\n " "^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "hello"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _+_(\n "hello"~string,\n " "~string\n )~string^add_string,\n "hello"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "concat_empty_string_beginning", - expr: "'' + 'abc'", - value: { stringValue: "abc" }, - }, - ast: '_+_(\n ""^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n ""~string,\n "abc"~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "concat_empty_string_end", - expr: "'abc' + ''", - value: { stringValue: "abc" }, - }, - ast: '_+_(\n "abc"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n "abc"~string,\n ""~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "concat_empty_with_empty", - expr: "'' + ''", - value: { stringValue: "" }, - }, - ast: '_+_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n ""~string,\n ""~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "unicode_unicode", - expr: "'¢' + 'ÿ' + 'Ȁ'", - value: { stringValue: "¢ÿȀ" }, - }, - ast: '_+_(\n _+_(\n "¢"^#*expr.Constant_StringValue#,\n "ÿ"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "Ȁ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n _+_(\n "¢"~string,\n "ÿ"~string\n )~string^add_string,\n "Ȁ"~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "ascii_unicode", - expr: "'r' + 'ô' + 'le'", - value: { stringValue: "rôle" }, - }, - ast: '_+_(\n _+_(\n "r"^#*expr.Constant_StringValue#,\n "ô"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "le"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n _+_(\n "r"~string,\n "ô"~string\n )~string^add_string,\n "le"~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "ascii_unicode_unicode_smp", - expr: "'a' + 'ÿ' + '🐱'", - value: { stringValue: "aÿ🐱" }, - }, - ast: '_+_(\n _+_(\n "a"^#*expr.Constant_StringValue#,\n "ÿ"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "🐱"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n _+_(\n "a"~string,\n "ÿ"~string\n )~string^add_string,\n "🐱"~string\n)~string^add_string', - type: "string", - }, - { - original: { - name: "empty_unicode", - expr: "'' + 'Ω' + ''", - value: { stringValue: "Ω" }, - }, - ast: '_+_(\n _+_(\n ""^#*expr.Constant_StringValue#,\n "Ω"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n _+_(\n ""~string,\n "Ω"~string\n )~string^add_string,\n ""~string\n)~string^add_string', - type: "string", - }, - ], - }, - { - name: "contains", - tests: [ - { - original: { - name: "contains_true", - expr: "'hello'.contains('he')", - value: { boolValue: true }, - }, - ast: '"hello"^#*expr.Constant_StringValue#.contains(\n "he"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"hello"~string.contains(\n "he"~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "contains_empty", - expr: "'hello'.contains('')", - value: { boolValue: true }, - }, - ast: '"hello"^#*expr.Constant_StringValue#.contains(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"hello"~string.contains(\n ""~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "contains_false", - expr: "'hello'.contains('ol')", - value: { boolValue: false }, - }, - ast: '"hello"^#*expr.Constant_StringValue#.contains(\n "ol"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"hello"~string.contains(\n "ol"~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "contains_multiple", - expr: "'abababc'.contains('ababc')", - value: { boolValue: true }, - }, - ast: '"abababc"^#*expr.Constant_StringValue#.contains(\n "ababc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"abababc"~string.contains(\n "ababc"~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "contains_unicode", - expr: "'Straße'.contains('aß')", - value: { boolValue: true }, - }, - ast: '"Straße"^#*expr.Constant_StringValue#.contains(\n "aß"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"Straße"~string.contains(\n "aß"~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "contains_unicode_smp", - expr: "'🐱😀😁'.contains('😀')", - value: { boolValue: true }, - }, - ast: '"🐱😀😁"^#*expr.Constant_StringValue#.contains(\n "😀"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"🐱😀😁"~string.contains(\n "😀"~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "empty_contains", - expr: "''.contains('something')", - value: { boolValue: false }, - }, - ast: '""^#*expr.Constant_StringValue#.contains(\n "something"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.contains(\n "something"~string\n)~bool^contains_string', - type: "bool", - }, - { - original: { - name: "empty_empty", - expr: "''.contains('')", - value: { boolValue: true }, - }, - ast: '""^#*expr.Constant_StringValue#.contains(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '""~string.contains(\n ""~string\n)~bool^contains_string', - type: "bool", - }, - ], - }, - { - name: "bytes_concat", - tests: [ - { - original: { - name: "concat", - expr: "b'abc' + b'def'", - value: { bytesValue: "YWJjZGVm" }, - }, - ast: '_+_(\n b"abc"^#*expr.Constant_BytesValue#,\n b"def"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n b"abc"~bytes,\n b"def"~bytes\n)~bytes^add_bytes', - type: "bytes", - }, - { - original: { - name: "left_unit", - expr: "b'' + b'\\xffoo'", - value: { bytesValue: "/29v" }, - }, - ast: '_+_(\n b""^#*expr.Constant_BytesValue#,\n b"\\xffoo"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n b""~bytes,\n b"\\xffoo"~bytes\n)~bytes^add_bytes', - type: "bytes", - }, - { - original: { - name: "right_unit", - expr: "b'zxy' + b''", - value: { bytesValue: "enh5" }, - }, - ast: '_+_(\n b"zxy"^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n b"zxy"~bytes,\n b""~bytes\n)~bytes^add_bytes', - type: "bytes", - }, - { - original: { - name: "empty_empty", - expr: "b'' + b''", - value: { bytesValue: "" }, - }, - ast: '_+_(\n b""^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: '_+_(\n b""~bytes,\n b""~bytes\n)~bytes^add_bytes', - type: "bytes", - }, - ], - }, - ], - }, - { - name: "string_ext", - suites: [ - { - name: "char_at", - tests: [ - { - original: { - name: "middle_index", - expr: "'tacocat'.charAt(3)", - value: { stringValue: "o" }, - }, - ast: '"tacocat"^#*expr.Constant_StringValue#.charAt(\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"tacocat"~string.charAt(\n 3~int\n)~string^string_char_at_int', - type: "string", - }, - { - original: { - name: "end_index", - expr: "'tacocat'.charAt(7)", - value: { stringValue: "" }, - }, - ast: '"tacocat"^#*expr.Constant_StringValue#.charAt(\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"tacocat"~string.charAt(\n 7~int\n)~string^string_char_at_int', - type: "string", - }, - { - original: { - name: "multiple", - expr: "'©αT'.charAt(0) == '©' \u0026\u0026 '©αT'.charAt(1) == 'α' \u0026\u0026 '©αT'.charAt(2) == 'T'", - }, - ast: '_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n "©αT"^#*expr.Constant_StringValue#.charAt(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "©"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n "©αT"^#*expr.Constant_StringValue#.charAt(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "α"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _==_(\n "©αT"^#*expr.Constant_StringValue#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "T"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n "©αT"~string.charAt(\n 0~int\n )~string^string_char_at_int,\n "©"~string\n )~bool^equals,\n _==_(\n "©αT"~string.charAt(\n 1~int\n )~string^string_char_at_int,\n "α"~string\n )~bool^equals\n )~bool^logical_and,\n _==_(\n "©αT"~string.charAt(\n 2~int\n )~string^string_char_at_int,\n "T"~string\n )~bool^equals\n)~bool^logical_and', - type: "bool", - }, - ], - }, - { - name: "index_of", - tests: [ - { - original: { - name: "empty_index", - expr: "'tacocat'.indexOf('')", - value: { int64Value: "0" }, - }, - ast: '"tacocat"^#*expr.Constant_StringValue#.indexOf(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"tacocat"~string.indexOf(\n ""~string\n)~int^string_index_of_string', - type: "int", - }, - { - original: { - name: "string_index", - expr: "'tacocat'.indexOf('ac')", - value: { int64Value: "1" }, - }, - ast: '"tacocat"^#*expr.Constant_StringValue#.indexOf(\n "ac"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"tacocat"~string.indexOf(\n "ac"~string\n)~int^string_index_of_string', - type: "int", - }, - { - original: { - name: "nomatch", - expr: "'tacocat'.indexOf('none') == -1", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "none"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.indexOf(\n "none"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "empty_index", - expr: "'tacocat'.indexOf('', 3) == 3", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n ""^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.indexOf(\n ""~string,\n 3~int\n )~int^string_index_of_string_int,\n 3~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "char_index", - expr: "'tacocat'.indexOf('a', 3) == 5", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "a"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.indexOf(\n "a"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_index", - expr: "'tacocat'.indexOf('at', 3) == 5", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "at"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.indexOf(\n "at"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_char", - expr: "'ta©o©αT'.indexOf('©') == 2", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.indexOf(\n "©"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_char_index", - expr: "'ta©o©αT'.indexOf('©', 3) == 4", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.indexOf(\n "©"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_string_index", - expr: "'ta©o©αT'.indexOf('©αT', 3) == 4", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©αT"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.indexOf(\n "©αT"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_string_nomatch_index", - expr: "'ta©o©αT'.indexOf('©α', 5) == -1", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©α"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.indexOf(\n "©α"~string,\n 5~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { name: "char_index", expr: "'ijk'.indexOf('k') == 2" }, - ast: '_==_(\n "ijk"^#*expr.Constant_StringValue#.indexOf(\n "k"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ijk"~string.indexOf(\n "k"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_with_space_fullmatch", - expr: "'hello wello'.indexOf('hello wello') == 0", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.indexOf(\n "hello wello"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.indexOf(\n "hello wello"~string\n )~int^string_index_of_string,\n 0~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_with_space_index", - expr: "'hello wello'.indexOf('ello', 6) == 7", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.indexOf(\n "ello"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.indexOf(\n "ello"~string,\n 6~int\n )~int^string_index_of_string_int,\n 7~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_nomatch_index", - expr: "'hello wello'.indexOf('elbo room!!') == -1", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.indexOf(\n "elbo room!!"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.indexOf(\n "elbo room!!"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "last_index_of", - tests: [ - { - original: { - name: "empty_string", - expr: "''.lastIndexOf('@@') == -1", - }, - ast: '_==_(\n ""^#*expr.Constant_StringValue#.lastIndexOf(\n "@@"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n ""~string.lastIndexOf(\n "@@"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "empty_argument", - expr: "'tacocat'.lastIndexOf('') == 7", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n ""~string\n )~int^string_last_index_of_string,\n 7~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string", - expr: "'tacocat'.lastIndexOf('at') == 5", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "at"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n "at"~string\n )~int^string_last_index_of_string,\n 5~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_nomatch", - expr: "'tacocat'.lastIndexOf('none') == -1", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "none"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n "none"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "empty_index", - expr: "'tacocat'.lastIndexOf('', 3) == 3", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n ""^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n ""~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 3~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "char_index", - expr: "'tacocat'.lastIndexOf('a', 3) == 1", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "a"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n "a"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_char", - expr: "'ta©o©αT'.lastIndexOf('©') == 4", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.lastIndexOf(\n "©"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.lastIndexOf(\n "©"~string\n )~int^string_last_index_of_string,\n 4~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_char_index", - expr: "'ta©o©αT'.lastIndexOf('©', 3) == 2", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.lastIndexOf(\n "©"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.lastIndexOf(\n "©"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 2~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_string_index", - expr: "'ta©o©αT'.lastIndexOf('©α', 4) == 4", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.lastIndexOf(\n "©α"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.lastIndexOf(\n "©α"~string,\n 4~int\n )~int^string_last_index_of_string_int,\n 4~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_with_space_string_index", - expr: "'hello wello'.lastIndexOf('ello', 6) == 1", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "ello"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.lastIndexOf(\n "ello"~string,\n 6~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_with_space_string_nomatch", - expr: "'hello wello'.lastIndexOf('low') == -1", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "low"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.lastIndexOf(\n "low"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_with_space_string_with_space_nomatch", - expr: "'hello wello'.lastIndexOf('elbo room!!') == -1", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "elbo room!!"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.lastIndexOf(\n "elbo room!!"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "string_with_space_fullmatch", - expr: "'hello wello'.lastIndexOf('hello wello') == 0", - }, - ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "hello wello"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello wello"~string.lastIndexOf(\n "hello wello"~string\n )~int^string_last_index_of_string,\n 0~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "repeated_string", - expr: "'bananananana'.lastIndexOf('nana', 7) == 6", - }, - ast: '_==_(\n "bananananana"^#*expr.Constant_StringValue#.lastIndexOf(\n "nana"^#*expr.Constant_StringValue#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "bananananana"~string.lastIndexOf(\n "nana"~string,\n 7~int\n )~int^string_last_index_of_string_int,\n 6~int\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "ascii_casing", - tests: [ - { - original: { - name: "lowerascii", - expr: "'TacoCat'.lowerAscii() == 'tacocat'", - }, - ast: '_==_(\n "TacoCat"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n "tacocat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "TacoCat"~string.lowerAscii()~string^string_lower_ascii,\n "tacocat"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "lowerascii_unicode", - expr: "'TacoCÆt'.lowerAscii() == 'tacocÆt'", - }, - ast: '_==_(\n "TacoCÆt"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n "tacocÆt"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "TacoCÆt"~string.lowerAscii()~string^string_lower_ascii,\n "tacocÆt"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "lowerascii_unicode_with_space", - expr: "'TacoCÆt Xii'.lowerAscii() == 'tacocÆt xii'", - }, - ast: '_==_(\n "TacoCÆt Xii"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n "tacocÆt xii"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "TacoCÆt Xii"~string.lowerAscii()~string^string_lower_ascii,\n "tacocÆt xii"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "upperascii", - expr: "'tacoCat'.upperAscii() == 'TACOCAT'", - }, - ast: '_==_(\n "tacoCat"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n "TACOCAT"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacoCat"~string.upperAscii()~string^string_upper_ascii,\n "TACOCAT"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "upperascii_unicode", - expr: "'tacoCαt'.upperAscii() == 'TACOCαT'", - }, - ast: '_==_(\n "tacoCαt"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n "TACOCαT"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacoCαt"~string.upperAscii()~string^string_upper_ascii,\n "TACOCαT"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "upperascii_unicode_with_space", - expr: "'TacoCÆt Xii'.upperAscii() == 'TACOCÆT XII'", - }, - ast: '_==_(\n "TacoCÆt Xii"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n "TACOCÆT XII"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "TacoCÆt Xii"~string.upperAscii()~string^string_upper_ascii,\n "TACOCÆT XII"~string\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "replace", - tests: [ - { - original: { - name: "no_placeholder", - expr: "'12 days 12 hours'.replace('{0}', '2') == '12 days 12 hours'", - }, - ast: '_==_(\n "12 days 12 hours"^#*expr.Constant_StringValue#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "12 days 12 hours"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "12 days 12 hours"~string.replace(\n "{0}"~string,\n "2"~string\n )~string^string_replace_string_string,\n "12 days 12 hours"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "basic", - expr: "'{0} days {0} hours'.replace('{0}', '2') == '2 days 2 hours'", - }, - ast: '_==_(\n "{0} days {0} hours"^#*expr.Constant_StringValue#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "2 days 2 hours"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "{0} days {0} hours"~string.replace(\n "{0}"~string,\n "2"~string\n )~string^string_replace_string_string,\n "2 days 2 hours"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "chained", - expr: "'{0} days {0} hours'.replace('{0}', '2', 1).replace('{0}', '23') == '2 days 23 hours'", - }, - ast: '_==_(\n "{0} days {0} hours"^#*expr.Constant_StringValue#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "23"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "2 days 23 hours"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "{0} days {0} hours"~string.replace(\n "{0}"~string,\n "2"~string,\n 1~int\n )~string^string_replace_string_string_int.replace(\n "{0}"~string,\n "23"~string\n )~string^string_replace_string_string,\n "2 days 23 hours"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode", - expr: "'1 ©αT taco'.replace('αT', 'o©α') == '1 ©o©α taco'", - }, - ast: '_==_(\n "1 ©αT taco"^#*expr.Constant_StringValue#.replace(\n "αT"^#*expr.Constant_StringValue#,\n "o©α"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "1 ©o©α taco"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "1 ©αT taco"~string.replace(\n "αT"~string,\n "o©α"~string\n )~string^string_replace_string_string,\n "1 ©o©α taco"~string\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "split", - tests: [ - { - original: { - name: "empty", - expr: "'hello world'.split(' ') == ['hello', 'world']", - }, - ast: '_==_(\n "hello world"^#*expr.Constant_StringValue#.split(\n " "^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "hello"^#*expr.Constant_StringValue#,\n "world"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello world"~string.split(\n " "~string\n )~list(string)^string_split_string,\n [\n "hello"~string,\n "world"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "zero_limit", - expr: "'hello world events!'.split(' ', 0) == []", - }, - ast: '_==_(\n "hello world events!"^#*expr.Constant_StringValue#.split(\n " "^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello world events!"~string.split(\n " "~string,\n 0~int\n )~list(string)^string_split_string_int,\n []~list(string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "one_limit", - expr: "'hello world events!'.split(' ', 1) == ['hello world events!']", - }, - ast: '_==_(\n "hello world events!"^#*expr.Constant_StringValue#.split(\n " "^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "hello world events!"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "hello world events!"~string.split(\n " "~string,\n 1~int\n )~list(string)^string_split_string_int,\n [\n "hello world events!"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_negative_limit", - expr: "'o©o©o©o'.split('©', -1) == ['o', 'o', 'o', 'o']", - }, - ast: '_==_(\n "o©o©o©o"^#*expr.Constant_StringValue#.split(\n "©"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "o"^#*expr.Constant_StringValue#,\n "o"^#*expr.Constant_StringValue#,\n "o"^#*expr.Constant_StringValue#,\n "o"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "o©o©o©o"~string.split(\n "©"~string,\n -1~int\n )~list(string)^string_split_string_int,\n [\n "o"~string,\n "o"~string,\n "o"~string,\n "o"~string\n ]~list(string)\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "substring", - tests: [ - { - original: { - name: "start", - expr: "'tacocat'.substring(4) == 'cat'", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 4~int\n )~string^string_substring_int,\n "cat"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "start_with_max_length", - expr: "'tacocat'.substring(7) == ''", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 7~int\n )~string^string_substring_int,\n ""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "start_and_end", - expr: "'tacocat'.substring(0, 4) == 'taco'", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "taco"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 0~int,\n 4~int\n )~string^string_substring_int_int,\n "taco"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "start_and_end_equal_value", - expr: "'tacocat'.substring(4, 4) == ''", - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 4~int,\n 4~int\n )~string^string_substring_int_int,\n ""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_start_and_end", - expr: "'ta©o©αT'.substring(2, 6) == '©o©α'", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.substring(\n 2^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "©o©α"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.substring(\n 2~int,\n 6~int\n )~string^string_substring_int_int,\n "©o©α"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_start_and_end_equal_value", - expr: "'ta©o©αT'.substring(7, 7) == ''", - }, - ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "ta©o©αT"~string.substring(\n 7~int,\n 7~int\n )~string^string_substring_int_int,\n ""~string\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "trim", - tests: [ - { - original: { - name: "blank_spaces_escaped_chars", - expr: "' \\f\\n\\r\\t\\vtext '.trim() == 'text'", - }, - ast: '_==_(\n " \\f\\n\\r\\t\\vtext "^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n " \\f\\n\\r\\t\\vtext "~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_space_chars_1", - expr: "'\\u0085\\u00a0\\u1680text'.trim() == 'text'", - }, - ast: '_==_(\n "\\u0085\\u00a0\\u1680text"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "\\u0085\\u00a0\\u1680text"~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_space_chars_2", - expr: "'text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009'.trim() == 'text'", - }, - ast: '_==_(\n "text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009"~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_space_chars_3", - expr: "'\\u200atext\\u2028\\u2029\\u202F\\u205F\\u3000'.trim() == 'text'", - }, - ast: '_==_(\n "\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000"~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_no_trim", - expr: "'\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'.trim() == '\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'", - }, - ast: '_==_(\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"~string.trim()~string^string_trim,\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"~string\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "join", - tests: [ - { - original: { - name: "empty_separator", - expr: "['x', 'y'].join() == 'xy'", - }, - ast: '_==_(\n [\n "x"^#*expr.Constant_StringValue#,\n "y"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n "xy"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n [\n "x"~string,\n "y"~string\n ]~list(string).join()~string^list_join,\n "xy"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "dash_separator", - expr: "['x', 'y'].join('-') == 'x-y'", - }, - ast: '_==_(\n [\n "x"^#*expr.Constant_StringValue#,\n "y"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join(\n "-"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "x-y"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n [\n "x"~string,\n "y"~string\n ]~list(string).join(\n "-"~string\n )~string^list_join_string,\n "x-y"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "empty_string_empty_separator", - expr: "[].join() == ''", - }, - ast: '_==_(\n []^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n []~list(string).join()~string^list_join,\n ""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "empty_string_dash_separator", - expr: "[].join('-') == ''", - }, - ast: '_==_(\n []^#*expr.Expr_ListExpr#.join(\n "-"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n []~list(string).join(\n "-"~string\n )~string^list_join_string,\n ""~string\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "quote", - tests: [ - { - original: { - name: "multiline", - expr: 'strings.quote("first\\nsecond") == "\\"first\\\\nsecond\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "first\\nsecond"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"first\\\\nsecond\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "first\\nsecond"~string\n )~string^strings_quote,\n "\\"first\\\\nsecond\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "escaped", - expr: 'strings.quote("bell\\a") == "\\"bell\\\\a\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "bell\\a"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"bell\\\\a\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "bell\\a"~string\n )~string^strings_quote,\n "\\"bell\\\\a\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "backspace", - expr: 'strings.quote("\\bbackspace") == "\\"\\\\bbackspace\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "\\bbackspace"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"\\\\bbackspace\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "\\bbackspace"~string\n )~string^strings_quote,\n "\\"\\\\bbackspace\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "form_feed", - expr: 'strings.quote("\\fform feed") == "\\"\\\\fform feed\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "\\fform feed"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"\\\\fform feed\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "\\fform feed"~string\n )~string^strings_quote,\n "\\"\\\\fform feed\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "carriage_return", - expr: 'strings.quote("carriage \\r return") == "\\"carriage \\\\r return\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "carriage \\r return"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"carriage \\\\r return\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "carriage \\r return"~string\n )~string^strings_quote,\n "\\"carriage \\\\r return\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "horizontal_tab", - expr: 'strings.quote("horizontal tab\\t") == "\\"horizontal tab\\\\t\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "horizontal tab\\t"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"horizontal tab\\\\t\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "horizontal tab\\t"~string\n )~string^strings_quote,\n "\\"horizontal tab\\\\t\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "vertical_tab", - expr: 'strings.quote("vertical \\v tab") == "\\"vertical \\\\v tab\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "vertical \\v tab"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"vertical \\\\v tab\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "vertical \\v tab"~string\n )~string^strings_quote,\n "\\"vertical \\\\v tab\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "double_slash", - expr: 'strings.quote("double \\\\\\\\ slash") == "\\"double \\\\\\\\\\\\\\\\ slash\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "double \\\\\\\\ slash"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"double \\\\\\\\\\\\\\\\ slash\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "double \\\\\\\\ slash"~string\n )~string^strings_quote,\n "\\"double \\\\\\\\\\\\\\\\ slash\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "two_escape_sequences", - expr: 'strings.quote("two escape sequences \\\\a\\\\n") == "\\"two escape sequences \\\\\\\\a\\\\\\\\n\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "two escape sequences \\\\a\\\\n"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"two escape sequences \\\\\\\\a\\\\\\\\n\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "two escape sequences \\\\a\\\\n"~string\n )~string^strings_quote,\n "\\"two escape sequences \\\\\\\\a\\\\\\\\n\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "verbatim", - expr: 'strings.quote("verbatim") == "\\"verbatim\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "verbatim"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"verbatim\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "verbatim"~string\n )~string^strings_quote,\n "\\"verbatim\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "ends_with", - expr: 'strings.quote("ends with \\\\") == "\\"ends with \\\\\\\\\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "ends with \\\\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"ends with \\\\\\\\\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "ends with \\\\"~string\n )~string^strings_quote,\n "\\"ends with \\\\\\\\\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "starts_with", - expr: 'strings.quote("\\\\ starts with") == "\\"\\\\\\\\ starts with\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "\\\\ starts with"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"\\\\\\\\ starts with\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "\\\\ starts with"~string\n )~string^strings_quote,\n "\\"\\\\\\\\ starts with\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "printable_unicode", - expr: 'strings.quote("printable unicode😀") == "\\"printable unicode😀\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "printable unicode😀"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"printable unicode😀\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "printable unicode😀"~string\n )~string^strings_quote,\n "\\"printable unicode😀\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "mid_string_quote", - expr: 'strings.quote("mid string \\" quote") == "\\"mid string \\\\\\" quote\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "mid string \\" quote"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"mid string \\\\\\" quote\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "mid string \\" quote"~string\n )~string^strings_quote,\n "\\"mid string \\\\\\" quote\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "single_quote_with_double_quote", - expr: 'strings.quote(\'single-quote with "double quote"\') == "\\"single-quote with \\\\\\"double quote\\\\\\"\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "single-quote with \\"double quote\\""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"single-quote with \\\\\\"double quote\\\\\\"\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "single-quote with \\"double quote\\""~string\n )~string^strings_quote,\n "\\"single-quote with \\\\\\"double quote\\\\\\"\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "size_unicode_char", - expr: 'strings.quote("size(\'ÿ\')") == "\\"size(\'ÿ\')\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "size(\'ÿ\')"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"size(\'ÿ\')\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "size(\'ÿ\')"~string\n )~string^strings_quote,\n "\\"size(\'ÿ\')\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "size_unicode_string", - expr: 'strings.quote("size(\'πέντε\')") == "\\"size(\'πέντε\')\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "size(\'πέντε\')"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"size(\'πέντε\')\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "size(\'πέντε\')"~string\n )~string^strings_quote,\n "\\"size(\'πέντε\')\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode", - expr: 'strings.quote("завтра") == "\\"завтра\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "завтра"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"завтра\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "завтра"~string\n )~string^strings_quote,\n "\\"завтра\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "unicode_code_points", - expr: 'strings.quote("\\U0001F431\\U0001F600\\U0001F61B")', - value: { stringValue: '"🐱😀😛"' }, - }, - ast: 'strings^#*expr.Expr_IdentExpr#.quote(\n "🐱😀😛"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'strings.quote(\n "🐱😀😛"~string\n)~string^strings_quote', - type: "string", - }, - { - original: { - name: "unicode_2", - expr: 'strings.quote("ta©o©αT") == "\\"ta©o©αT\\""', - }, - ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "ta©o©αT"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"ta©o©αT\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n strings.quote(\n "ta©o©αT"~string\n )~string^strings_quote,\n "\\"ta©o©αT\\""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "empty_quote", - expr: 'strings.quote("")', - value: { stringValue: '""' }, - }, - ast: 'strings^#*expr.Expr_IdentExpr#.quote(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: 'strings.quote(\n ""~string\n)~string^strings_quote', - type: "string", - }, - ], - }, - { - name: "format", - tests: [ - { - original: { - name: "no-op", - expr: '"no substitution".format([])', - value: { stringValue: "no substitution" }, - }, - ast: '"no substitution"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"no substitution"~string.format(\n []~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "mid-string substitution", - expr: '"str is %s and some more".format(["filler"])', - value: { stringValue: "str is filler and some more" }, - }, - ast: '"str is %s and some more"^#*expr.Constant_StringValue#.format(\n [\n "filler"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"str is %s and some more"~string.format(\n [\n "filler"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "percent escaping", - expr: '"%% and also %%".format([])', - value: { stringValue: "% and also %" }, - }, - ast: '"%% and also %%"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%% and also %%"~string.format(\n []~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "substitution inside escaped percent signs", - expr: '"%%%s%%".format(["text"])', - value: { stringValue: "%text%" }, - }, - ast: '"%%%s%%"^#*expr.Constant_StringValue#.format(\n [\n "text"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%%%s%%"~string.format(\n [\n "text"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "substitution with one escaped percent sign on the right", - expr: '"%s%%".format(["percent on the right"])', - value: { stringValue: "percent on the right%" }, - }, - ast: '"%s%%"^#*expr.Constant_StringValue#.format(\n [\n "percent on the right"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s%%"~string.format(\n [\n "percent on the right"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "substitution with one escaped percent sign on the left", - expr: '"%%%s".format(["percent on the left"])', - value: { stringValue: "%percent on the left" }, - }, - ast: '"%%%s"^#*expr.Constant_StringValue#.format(\n [\n "percent on the left"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%%%s"~string.format(\n [\n "percent on the left"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "multiple substitutions", - expr: '"%d %d %d, %s %s %s, %d %d %d, %s %s %s".format([1, 2, 3, "A", "B", "C", 4, 5, 6, "D", "E", "F"])', - value: { stringValue: "1 2 3, A B C, 4 5 6, D E F" }, - }, - ast: '"%d %d %d, %s %s %s, %d %d %d, %s %s %s"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n "A"^#*expr.Constant_StringValue#,\n "B"^#*expr.Constant_StringValue#,\n "C"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n "D"^#*expr.Constant_StringValue#,\n "E"^#*expr.Constant_StringValue#,\n "F"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d %d %d, %s %s %s, %d %d %d, %s %s %s"~string.format(\n [\n 1~int,\n 2~int,\n 3~int,\n "A"~string,\n "B"~string,\n "C"~string,\n 4~int,\n 5~int,\n 6~int,\n "D"~string,\n "E"~string,\n "F"~string\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "percent sign escape sequence support", - expr: '"%%escaped %s%%".format(["percent"])', - value: { stringValue: "%escaped percent%" }, - }, - ast: '"%%escaped %s%%"^#*expr.Constant_StringValue#.format(\n [\n "percent"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%%escaped %s%%"~string.format(\n [\n "percent"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "fixed point formatting clause", - expr: '"%.3f".format([1.2345])', - value: { stringValue: "1.234" }, - }, - ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.3f"~string.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "binary formatting clause", - expr: '"this is 5 in binary: %b".format([5])', - value: { stringValue: "this is 5 in binary: 101" }, - }, - ast: '"this is 5 in binary: %b"^#*expr.Constant_StringValue#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"this is 5 in binary: %b"~string.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "uint support for binary formatting", - expr: '"unsigned 64 in binary: %b".format([uint(64)])', - value: { stringValue: "unsigned 64 in binary: 1000000" }, - }, - ast: '"unsigned 64 in binary: %b"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"unsigned 64 in binary: %b"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "bool support for binary formatting", - expr: '"bit set from bool: %b".format([true])', - value: { stringValue: "bit set from bool: 1" }, - }, - ast: '"bit set from bool: %b"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"bit set from bool: %b"~string.format(\n [\n true~bool\n ]~list(bool)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "octal formatting clause", - expr: '"%o".format([11])', - value: { stringValue: "13" }, - }, - ast: '"%o"^#*expr.Constant_StringValue#.format(\n [\n 11^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%o"~string.format(\n [\n 11~int\n ]~list(int)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "uint support for octal formatting clause", - expr: '"this is an unsigned octal: %o".format([uint(65535)])', - value: { stringValue: "this is an unsigned octal: 177777" }, - }, - ast: '"this is an unsigned octal: %o"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 65535^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"this is an unsigned octal: %o"~string.format(\n [\n uint(\n 65535~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "lowercase hexadecimal formatting clause", - expr: '"%x is 20 in hexadecimal".format([30])', - value: { stringValue: "1e is 20 in hexadecimal" }, - }, - ast: '"%x is 20 in hexadecimal"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%x is 20 in hexadecimal"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "uppercase hexadecimal formatting clause", - expr: '"%X is 20 in hexadecimal".format([30])', - value: { stringValue: "1E is 20 in hexadecimal" }, - }, - ast: '"%X is 20 in hexadecimal"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%X is 20 in hexadecimal"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "unsigned support for hexadecimal formatting clause", - expr: '"%X is 6000 in hexadecimal".format([uint(6000)])', - value: { stringValue: "1770 is 6000 in hexadecimal" }, - }, - ast: '"%X is 6000 in hexadecimal"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 6000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%X is 6000 in hexadecimal"~string.format(\n [\n uint(\n 6000~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "string support with hexadecimal formatting clause", - expr: '"%x".format(["Hello world!"])', - value: { stringValue: "48656c6c6f20776f726c6421" }, - }, - ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n "Hello world!"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%x"~string.format(\n [\n "Hello world!"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "string support with uppercase hexadecimal formatting clause", - expr: '"%X".format(["Hello world!"])', - value: { stringValue: "48656C6C6F20776F726C6421" }, - }, - ast: '"%X"^#*expr.Constant_StringValue#.format(\n [\n "Hello world!"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%X"~string.format(\n [\n "Hello world!"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "byte support with hexadecimal formatting clause", - expr: '"%x".format([b"byte string"])', - value: { stringValue: "6279746520737472696e67" }, - }, - ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n b"byte string"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%x"~string.format(\n [\n b"byte string"~bytes\n ]~list(bytes)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "byte support with uppercase hexadecimal formatting clause", - expr: '"%X".format([b"byte string"])', - value: { stringValue: "6279746520737472696E67" }, - }, - ast: '"%X"^#*expr.Constant_StringValue#.format(\n [\n b"byte string"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%X"~string.format(\n [\n b"byte string"~bytes\n ]~list(bytes)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "scientific notation formatting clause", - expr: '"%.6e".format([1052.032911275])', - value: { stringValue: "1.052033e+03" }, - }, - ast: '"%.6e"^#*expr.Constant_StringValue#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.6e"~string.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "default precision for fixed-point clause", - expr: '"%f".format([2.71828])', - value: { stringValue: "2.718280" }, - }, - ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%f"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "default precision for scientific notation", - expr: '"%e".format([2.71828])', - value: { stringValue: "2.718280e+00" }, - }, - ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%e"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "NaN support for scientific notation", - expr: '"%e".format([double("NaN")])', - value: { stringValue: "NaN" }, - }, - ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%e"~string.format(\n [\n double(\n "NaN"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "positive infinity support for scientific notation", - expr: '"%e".format([double("Infinity")])', - value: { stringValue: "Infinity" }, - }, - ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%e"~string.format(\n [\n double(\n "Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "negative infinity support for scientific notation", - expr: '"%e".format([double("-Infinity")])', - value: { stringValue: "-Infinity" }, - }, - ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%e"~string.format(\n [\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "NaN support for decimal", - expr: '"%d".format([double("NaN")])', - value: { stringValue: "NaN" }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d"~string.format(\n [\n double(\n "NaN"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "positive infinity support for decimal", - expr: '"%d".format([double("Infinity")])', - value: { stringValue: "Infinity" }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d"~string.format(\n [\n double(\n "Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "negative infinity support for decimal", - expr: '"%d".format([double("-Infinity")])', - value: { stringValue: "-Infinity" }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d"~string.format(\n [\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "NaN support for fixed-point", - expr: '"%f".format([double("NaN")])', - value: { stringValue: "NaN" }, - }, - ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%f"~string.format(\n [\n double(\n "NaN"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "positive infinity support for fixed-point", - expr: '"%f".format([double("Infinity")])', - value: { stringValue: "Infinity" }, - }, - ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%f"~string.format(\n [\n double(\n "Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "negative infinity support for fixed-point", - expr: '"%f".format([double("-Infinity")])', - value: { stringValue: "-Infinity" }, - }, - ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%f"~string.format(\n [\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "uint support for decimal clause", - expr: '"%d".format([uint(64)])', - value: { stringValue: "64" }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "null support for string", - expr: '"%s".format([null])', - value: { stringValue: "null" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n null~null\n ]~list(null)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "int support for string", - expr: '"%s".format([999999999999])', - value: { stringValue: "999999999999" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n 999999999999^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n 999999999999~int\n ]~list(int)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "bytes support for string", - expr: '"%s".format([b"xyz"])', - value: { stringValue: "xyz" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n b"xyz"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n b"xyz"~bytes\n ]~list(bytes)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "type() support for string", - expr: '"%s".format([type("test string")])', - value: { stringValue: "string" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n type(\n "test string"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n type(\n "test string"~string\n )~type(string)^type\n ]~list(type(string))\n)~string^string_format', - type: "string", - }, - { - original: { - name: "timestamp support for string", - expr: '"%s".format([timestamp("2023-02-03T23:31:20+00:00")])', - value: { stringValue: "2023-02-03T23:31:20Z" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n timestamp(\n "2023-02-03T23:31:20+00:00"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n timestamp(\n "2023-02-03T23:31:20+00:00"~string\n )~timestamp^string_to_timestamp\n ]~list(timestamp)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "duration support for string", - expr: '"%s".format([duration("1h45m47s")])', - value: { stringValue: "6347s" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n duration(\n "1h45m47s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n duration(\n "1h45m47s"~string\n )~duration^string_to_duration\n ]~list(duration)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "list support for string", - expr: '"%s".format([["abc", 3.14, null, [9, 8, 7, 6], timestamp("2023-02-03T23:31:20Z")]])', - value: { - stringValue: - "[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]", - }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n [\n "abc"^#*expr.Constant_StringValue#,\n 3.14^#*expr.Constant_DoubleValue#,\n null^#*expr.Constant_NullValue#,\n [\n 9^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n timestamp(\n "2023-02-03T23:31:20Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n [\n "abc"~string,\n 3.14~double,\n null~null,\n [\n 9~int,\n 8~int,\n 7~int,\n 6~int\n ]~list(int),\n timestamp(\n "2023-02-03T23:31:20Z"~string\n )~timestamp^string_to_timestamp\n ]~list(dyn)\n ]~list(list(dyn))\n)~string^string_format', - type: "string", - }, - { - original: { - name: "map support for string", - expr: '"%s".format([{"key1": b"xyz", "key5": null, "key2": duration("2h"), "key4": true, "key3": 2.71828}])', - value: { - stringValue: - "{key1: xyz, key2: 7200s, key3: 2.71828, key4: true, key5: null}", - }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n "key1"^#*expr.Constant_StringValue#:b"xyz"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n "key5"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:duration(\n "2h"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "key4"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n "key3"^#*expr.Constant_StringValue#:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n {\n "key1"~string:b"xyz"~bytes,\n "key5"~string:null~null,\n "key2"~string:duration(\n "2h"~string\n )~duration^string_to_duration,\n "key4"~string:true~bool,\n "key3"~string:2.71828~double\n }~map(string, dyn)\n ]~list(map(string, dyn))\n)~string^string_format', - type: "string", - }, - { - original: { - name: "map support (all key types)", - expr: '"%s".format([{1: "value1", uint(2): "value2", true: double("NaN")}])', - value: { stringValue: "{1: value1, 2: value2, true: NaN}" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:"value1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n uint(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#:"value2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n {\n 1~int:"value1"~string,\n uint(\n 2~int\n )~uint^int64_to_uint64:"value2"~string,\n true~bool:double(\n "NaN"~string\n )~double^string_to_double\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format', - type: "string", - }, - { - original: { - name: "boolean support for %s", - expr: '"%s, %s".format([true, false])', - value: { stringValue: "true, false" }, - }, - ast: '"%s, %s"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s, %s"~string.format(\n [\n true~bool,\n false~bool\n ]~list(bool)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for string formatting clause", - expr: '"%s".format([dyn("a string")])', - value: { stringValue: "a string" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n "a string"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n dyn(\n "a string"~string\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for numbers with string formatting clause", - expr: '"%s, %s".format([dyn(32), dyn(56.8)])', - value: { stringValue: "32, 56.8" }, - }, - ast: '"%s, %s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 32^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 56.8^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s, %s"~string.format(\n [\n dyn(\n 32~int\n )~dyn^to_dyn,\n dyn(\n 56.8~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for integer formatting clause", - expr: '"%d".format([dyn(128)])', - value: { stringValue: "128" }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 128^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d"~string.format(\n [\n dyn(\n 128~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for integer formatting clause (unsigned)", - expr: '"%d".format([dyn(256u)])', - value: { stringValue: "256" }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 256u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%d"~string.format(\n [\n dyn(\n 256u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for hex formatting clause", - expr: '"%x".format([dyn(22)])', - value: { stringValue: "16" }, - }, - ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%x"~string.format(\n [\n dyn(\n 22~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for hex formatting clause (uppercase)", - expr: '"%X".format([dyn(26)])', - value: { stringValue: "1A" }, - }, - ast: '"%X"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 26^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%X"~string.format(\n [\n dyn(\n 26~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for unsigned hex formatting clause", - expr: '"%x".format([dyn(500u)])', - value: { stringValue: "1f4" }, - }, - ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 500u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%x"~string.format(\n [\n dyn(\n 500u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for fixed-point formatting clause", - expr: '"%.3f".format([dyn(4.5)])', - value: { stringValue: "4.500" }, - }, - ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 4.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.3f"~string.format(\n [\n dyn(\n 4.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for scientific notation", - expr: '"%e".format([dyn(2.71828)])', - value: { stringValue: "2.718280e+00" }, - }, - ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 2.71828^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%e"~string.format(\n [\n dyn(\n 2.71828~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype NaN/infinity support", - expr: '"%s".format([[double("NaN"), double("Infinity"), double("-Infinity")]])', - value: { stringValue: "[NaN, Infinity, -Infinity]" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n [\n double(\n "NaN"~string\n )~double^string_to_double,\n double(\n "Infinity"~string\n )~double^string_to_double,\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n ]~list(list(double))\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for timestamp", - expr: '"%s".format([dyn(timestamp("2009-11-10T23:00:00Z"))])', - value: { stringValue: "2009-11-10T23:00:00Z" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n timestamp(\n "2009-11-10T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n dyn(\n timestamp(\n "2009-11-10T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for duration", - expr: '"%s".format([dyn(duration("8747s"))])', - value: { stringValue: "8747s" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n duration(\n "8747s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n dyn(\n duration(\n "8747s"~string\n )~duration^string_to_duration\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for lists", - expr: '"%s".format([dyn([6, 4.2, "a string"])])', - value: { stringValue: "[6, 4.2, a string]" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n [\n 6^#*expr.Constant_Int64Value#,\n 4.2^#*expr.Constant_DoubleValue#,\n "a string"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n dyn(\n [\n 6~int,\n 4.2~double,\n "a string"~string\n ]~list(dyn)\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "dyntype support for maps", - expr: '"%s".format([{"strKey":"x", 6:duration("422s"), true:42}])', - value: { stringValue: "{6: 422s, strKey: x, true: 42}" }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n "strKey"^#*expr.Constant_StringValue#:"x"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:duration(\n "422s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%s"~string.format(\n [\n {\n "strKey"~string:"x"~string,\n 6~int:duration(\n "422s"~string\n )~duration^string_to_duration,\n true~bool:42~int\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format', - type: "string", - }, - { - original: { - name: "string substitution in a string variable", - expr: 'str_var.format(["filler"])', - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { str_var: { value: { stringValue: "%s" } } }, - value: { stringValue: "filler" }, - }, - ast: 'str_var^#*expr.Expr_IdentExpr#.format(\n [\n "filler"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'str_var~string^str_var.format(\n [\n "filler"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "multiple substitutions in a string variable", - expr: 'str_var.format([1, 2, 3, "A", "B", "C", 4, 5, 6, "D", "E", "F"])', - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { - str_var: { - value: { - stringValue: "%d %d %d, %s %s %s, %d %d %d, %s %s %s", - }, - }, - }, - value: { stringValue: "1 2 3, A B C, 4 5 6, D E F" }, - }, - ast: 'str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n "A"^#*expr.Constant_StringValue#,\n "B"^#*expr.Constant_StringValue#,\n "C"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n "D"^#*expr.Constant_StringValue#,\n "E"^#*expr.Constant_StringValue#,\n "F"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'str_var~string^str_var.format(\n [\n 1~int,\n 2~int,\n 3~int,\n "A"~string,\n "B"~string,\n "C"~string,\n 4~int,\n 5~int,\n 6~int,\n "D"~string,\n "E"~string,\n "F"~string\n ]~list(dyn)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "substitution inside escaped percent signs in a string variable", - expr: 'str_var.format(["text"])', - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { str_var: { value: { stringValue: "%%%s%%" } } }, - value: { stringValue: "%text%" }, - }, - ast: 'str_var^#*expr.Expr_IdentExpr#.format(\n [\n "text"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'str_var~string^str_var.format(\n [\n "text"~string\n ]~list(string)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "fixed point formatting clause in a string variable", - expr: "str_var.format([1.2345])", - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { str_var: { value: { stringValue: "%.3f" } } }, - value: { stringValue: "1.234" }, - }, - ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "str_var~string^str_var.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format", - type: "string", - }, - { - original: { - name: "binary formatting clause in a string variable", - expr: "str_var.format([5])", - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { str_var: { value: { stringValue: "%b" } } }, - value: { stringValue: "101" }, - }, - ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "str_var~string^str_var.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format", - type: "string", - }, - { - original: { - name: "scientific notation formatting clause in a string variable", - expr: "str_var.format([1052.032911275])", - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { str_var: { value: { stringValue: "%.6e" } } }, - value: { stringValue: "1.052033e+03" }, - }, - ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "str_var~string^str_var.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format", - type: "string", - }, - { - original: { - name: "default precision for fixed-point clause in a string variable", - expr: "str_var.format([2.71828])", - typeEnv: [ - { name: "str_var", ident: { type: { primitive: "STRING" } } }, - ], - bindings: { str_var: { value: { stringValue: "%f" } } }, - value: { stringValue: "2.718280" }, - }, - ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "str_var~string^str_var.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format", - type: "string", - }, - { - original: { - name: "format_%f_insignificant_zeroes_removed", - expr: '"%.0f".format([123.000000])', - value: { stringValue: "123" }, - }, - ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 123^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.0f"~string.format(\n [\n 123~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_positive_round_to_whole_number", - expr: '"%.0f".format([3.5001])', - value: { stringValue: "4" }, - }, - ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 3.5001^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.0f"~string.format(\n [\n 3.5001~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_negative_truncate_to_whole_number", - expr: '"%.0f".format([3.4999])', - value: { stringValue: "3" }, - }, - ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 3.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.0f"~string.format(\n [\n 3.4999~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_halfway_round_up_to_nearest_even", - expr: '"%.0f".format([1.5])', - value: { stringValue: "2" }, - }, - ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 1.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.0f"~string.format(\n [\n 1.5~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_halfway_truncate_to_nearest_even", - expr: '"%.0f".format([2.5])', - value: { stringValue: "2" }, - }, - ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 2.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.0f"~string.format(\n [\n 2.5~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_positive_round_up", - expr: '"%.3f".format([123.4999])', - value: { stringValue: "123.500" }, - }, - ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n 123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.3f"~string.format(\n [\n 123.4999~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_positive_round_down", - expr: '"%.3f".format([123.4994])', - value: { stringValue: "123.499" }, - }, - ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n 123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.3f"~string.format(\n [\n 123.4994~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_negative_round_up", - expr: '"%.3f".format([-123.4999])', - value: { stringValue: "-123.500" }, - }, - ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n -123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.3f"~string.format(\n [\n -123.4999~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_negative_round_down", - expr: '"%.3f".format([-123.4994])', - value: { stringValue: "-123.499" }, - }, - ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n -123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.3f"~string.format(\n [\n -123.4994~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - { - original: { - name: "format_%f_zero_padding", - expr: '"%.5f".format([-1.2])', - value: { stringValue: "-1.20000" }, - }, - ast: '"%.5f"^#*expr.Constant_StringValue#.format(\n [\n -1.2^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '"%.5f"~string.format(\n [\n -1.2~double\n ]~list(double)\n)~string^string_format', - type: "string", - }, - ], - }, - { - name: "format_errors", - tests: [ - { - original: { - name: "unrecognized formatting clause", - expr: '"%a".format([1])', - disableCheck: true, - evalError: { - errors: [ - { - message: - 'could not parse formatting clause: unrecognized formatting clause "a"', - }, - ], - }, - }, - ast: '"%a"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:12: could not parse formatting clause: unrecognized formatting clause "a"\n | "%a".format([1])\n | ...........^', - }, - { - original: { - name: "out of bounds arg index", - expr: '"%d %d %d".format([0, 1])', - disableCheck: true, - evalError: { errors: [{ message: "index 2 out of range" }] }, - }, - ast: '"%d %d %d"^#*expr.Constant_StringValue#.format(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:18: index 2 out of range\n | "%d %d %d".format([0, 1])\n | .................^', - }, - { - original: { - name: "string substitution is not allowed with binary clause", - expr: '"string is %b".format(["abc"])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: only integers and bools can be formatted as binary, was given string", - }, - ], - }, - }, - ast: '"string is %b"^#*expr.Constant_StringValue#.format(\n [\n "abc"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, and bools can be formatted as binary, was given string\n | "string is %b".format(["abc"])\n | .......................^', - }, - { - original: { - name: "duration substitution not allowed with decimal clause", - expr: '"%d".format([duration("30m2s")])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: decimal clause can only be used on integers, was given google.protobuf.Duration", - }, - ], - }, - }, - ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n duration(\n "30m2s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:22: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given google.protobuf.Duration\n | "%d".format([duration("30m2s")])\n | .....................^', - }, - { - original: { - name: "string substitution not allowed with octal clause", - expr: '"octal: %o".format(["a string"])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: octal clause can only be used on integers, was given string", - }, - ], - }, - }, - ast: '"octal: %o"^#*expr.Constant_StringValue#.format(\n [\n "a string"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:21: error during formatting: octal clause can only be used on ints and uints, was given string\n | "octal: %o".format(["a string"])\n | ....................^', - }, - { - original: { - name: "double substitution not allowed with hex clause", - expr: '"double is %x".format([0.5])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given double", - }, - ], - }, - }, - ast: '"double is %x"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given double\n | "double is %x".format([0.5])\n | .......................^', - }, - { - original: { - name: "uppercase not allowed for scientific clause", - expr: '"double is %E".format([0.5])', - disableCheck: true, - evalError: { - errors: [ - { - message: - 'could not parse formatting clause: unrecognized formatting clause "E"', - }, - ], - }, - }, - ast: '"double is %E"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:22: could not parse formatting clause: unrecognized formatting clause "E"\n | "double is %E".format([0.5])\n | .....................^', - }, - { - original: { - name: "object not allowed", - expr: '"object is %s".format([cel.expr.conformance.proto3.TestAllTypes{}])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - }, - ast: '"object is %s"^#*expr.Constant_StringValue#.format(\n [\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:64: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | "object is %s".format([cel.expr.conformance.proto3.TestAllTypes{}])\n | ...............................................................^', - }, - { - original: { - name: "object inside list", - expr: '"%s".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:61: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | "%s".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])\n | ............................................................^', - }, - { - original: { - name: "object inside map", - expr: '"%s".format([{1: "a", 2: cel.expr.conformance.proto3.TestAllTypes{}}])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - }, - ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:66: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | "%s".format([{1: "a", 2: cel.expr.conformance.proto3.TestAllTypes{}}])\n | .................................................................^', - }, - { - original: { - name: "null not allowed for %d", - expr: '"null: %d".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: decimal clause can only be used on integers, was given null_type", - }, - ], - }, - }, - ast: '"null: %d"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given null_type\n | "null: %d".format([null])\n | ...................^', - }, - { - original: { - name: "null not allowed for %e", - expr: '"null: %e".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: scientific clause can only be used on doubles, was given null_type", - }, - ], - }, - }, - ast: '"null: %e"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: scientific clause can only be used on ints, uints, and doubles, was given null_type\n | "null: %e".format([null])\n | ...................^', - }, - { - original: { - name: "null not allowed for %f", - expr: '"null: %f".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: fixed-point clause can only be used on doubles, was given null_type", - }, - ], - }, - }, - ast: '"null: %f"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: fixed-point clause can only be used on ints, uints, and doubles, was given null_type\n | "null: %f".format([null])\n | ...................^', - }, - { - original: { - name: "null not allowed for %x", - expr: '"null: %x".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type", - }, - ], - }, - }, - ast: '"null: %x"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | "null: %x".format([null])\n | ...................^', - }, - { - original: { - name: "null not allowed for %X", - expr: '"null: %X".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type", - }, - ], - }, - }, - ast: '"null: %X"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | "null: %X".format([null])\n | ...................^', - }, - { - original: { - name: "null not allowed for %b", - expr: '"null: %b".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: only integers and bools can be formatted as binary, was given null_type", - }, - ], - }, - }, - ast: '"null: %b"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, and bools can be formatted as binary, was given null_type\n | "null: %b".format([null])\n | ...................^', - }, - { - original: { - name: "null not allowed for %o", - expr: '"null: %o".format([null])', - disableCheck: true, - evalError: { - errors: [ - { - message: - "error during formatting: octal clause can only be used on integers, was given null_type", - }, - ], - }, - }, - ast: '"null: %o"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - 'ERROR: \u003cinput\u003e:1:20: error during formatting: octal clause can only be used on ints and uints, was given null_type\n | "null: %o".format([null])\n | ...................^', - }, - ], - }, - { - name: "value_errors", - tests: [ - { - original: { - name: "charat_out_of_range", - expr: "'tacocat'.charAt(30) == ''", - evalError: { errors: [{ message: "index out of range: 30" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.charAt(\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.charAt(\n 30~int\n )~string^string_char_at_int,\n ""~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "indexof_out_of_range", - expr: "'tacocat'.indexOf('a', 30) == -1", - evalError: { errors: [{ message: "index out of range: 30" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "a"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.indexOf(\n "a"~string,\n 30~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "lastindexof_negative_index", - expr: "'tacocat'.lastIndexOf('a', -1) == -1", - evalError: { errors: [{ message: "index out of range: -1" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "a"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n "a"~string,\n -1~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "lastindexof_out_of_range", - expr: "'tacocat'.lastIndexOf('a', 30) == -1", - evalError: { errors: [{ message: "index out of range: 30" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "a"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.lastIndexOf(\n "a"~string,\n 30~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "substring_out_of_range", - expr: "'tacocat'.substring(40) == 'cat'", - evalError: { errors: [{ message: "index out of range: 40" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 40^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 40~int\n )~string^string_substring_int,\n "cat"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "substring_negative_index", - expr: "'tacocat'.substring(-1) == 'cat'", - evalError: { errors: [{ message: "index out of range: -1" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n -1~int\n )~string^string_substring_int,\n "cat"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "substring_end_index_out_of_range", - expr: "'tacocat'.substring(1, 50) == 'cat'", - evalError: { errors: [{ message: "index out of range: 50" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 1~int,\n 50~int\n )~string^string_substring_int_int,\n "cat"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "substring_begin_index_out_of_range", - expr: "'tacocat'.substring(49, 50) == 'cat'", - evalError: { errors: [{ message: "index out of range: 49" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 49^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 49~int,\n 50~int\n )~string^string_substring_int_int,\n "cat"~string\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "substring_end_index_greater_than_begin_index", - expr: "'tacocat'.substring(4, 3) == ''", - evalError: { - errors: [ - { message: "invalid substring range. start: 4, end: 3" }, - ], - }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n "tacocat"~string.substring(\n 4~int,\n 3~int\n )~string^string_substring_int_int,\n ""~string\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "type_errors", - tests: [ - { - original: { - name: "charat_invalid_type", - expr: "42.charAt(2) == ''", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:10: found no matching overload for 'charAt' applied to 'int.(int)'\n | 42.charAt(2) == ''\n | .........^", - }, - { - original: { - name: "charat_invalid_argument", - expr: "'hello'.charAt(true) == ''", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "hello"^#*expr.Constant_StringValue#.charAt(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:15: found no matching overload for 'charAt' applied to 'string.(bool)'\n | 'hello'.charAt(true) == ''\n | ..............^", - }, - { - original: { - name: "indexof_unary_invalid_type", - expr: "24.indexOf('2') == 0", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 24^#*expr.Constant_Int64Value#.indexOf(\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string)'\n | 24.indexOf('2') == 0\n | ..........^", - }, - { - original: { - name: "indexof_unary_invalid_argument", - expr: "'hello'.indexOf(true) == 1", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "hello"^#*expr.Constant_StringValue#.indexOf(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:16: found no matching overload for 'indexOf' applied to 'string.(bool)'\n | 'hello'.indexOf(true) == 1\n | ...............^", - }, - { - original: { - name: "indexof_binary_invalid_argument", - expr: "42.indexOf('4', 0) == 0", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.indexOf(\n "4"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string, int)'\n | 42.indexOf('4', 0) == 0\n | ..........^", - }, - { - original: { - name: "indexof_binary_invalid_argument_2", - expr: "'42'.indexOf(4, 0) == 0", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.indexOf(\n 4^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(int, int)'\n | '42'.indexOf(4, 0) == 0\n | ............^", - }, - { - original: { - name: "indexof_binary_both_invalid_arguments", - expr: "'42'.indexOf('4', '0') == 0", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.indexOf(\n "4"^#*expr.Constant_StringValue#,\n "0"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, string)'\n | '42'.indexOf('4', '0') == 0\n | ............^", - }, - { - original: { - name: "indexof_ternary_invalid_arguments", - expr: "'42'.indexOf('4', 0, 1) == 0", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.indexOf(\n "4"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, int, int)'\n | '42'.indexOf('4', 0, 1) == 0\n | ............^", - }, - { - original: { - name: "split_invalid_type", - expr: "42.split('2') == ['4']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.split(\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('2') == ['4']\n | ........^", - }, - { - original: { - name: "replace_invalid_type", - expr: "42.replace(2, 1) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(int, int)'\n | 42.replace(2, 1) == '41'\n | ..........^", - }, - { - original: { - name: "replace_binary_invalid_argument", - expr: "'42'.replace(2, 1) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, int)'\n | '42'.replace(2, 1) == '41'\n | ............^", - }, - { - original: { - name: "replace_binary_invalid_argument_2", - expr: "'42'.replace('2', 1) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int)'\n | '42'.replace('2', 1) == '41'\n | ............^", - }, - { - original: { - name: "replace_ternary_invalid_argument", - expr: "42.replace('2', '1', 1) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(string, string, int)'\n | 42.replace('2', '1', 1) == '41'\n | ..........^", - }, - { - original: { - name: "replace_ternary_invalid_argument_2", - expr: "'42'.replace(2, '1', 1) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n "1"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, string, int)'\n | '42'.replace(2, '1', 1) == '41'\n | ............^", - }, - { - original: { - name: "replace_ternary_invalid_argument_3", - expr: "'42'.replace('2', 1, 1) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int, int)'\n | '42'.replace('2', 1, 1) == '41'\n | ............^", - }, - { - original: { - name: "replace_ternary_invalid_argument_4", - expr: "'42'.replace('2', '1', '1') == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, string)'\n | '42'.replace('2', '1', '1') == '41'\n | ............^", - }, - { - original: { - name: "replace_quaternary_invalid_argument", - expr: "'42'.replace('2', '1', 1, false) == '41'", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, int, bool)'\n | '42'.replace('2', '1', 1, false) == '41'\n | ............^", - }, - { - original: { - name: "split_invalid_type_empty_arg", - expr: "42.split('') == ['4', '2']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.split(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('') == ['4', '2']\n | ........^", - }, - { - original: { - name: "split_invalid_argument", - expr: "'42'.split(2) == ['4']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int)'\n | '42'.split(2) == ['4']\n | ..........^", - }, - { - original: { - name: "split_binary_invalid_type", - expr: "42.split('2', '1') == ['4']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 42^#*expr.Constant_Int64Value#.split(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string, string)'\n | 42.split('2', '1') == ['4']\n | ........^", - }, - { - original: { - name: "split_binary_invalid_argument", - expr: "'42'.split(2, 1) == ['4']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int, int)'\n | '42'.split(2, 1) == ['4']\n | ..........^", - }, - { - original: { - name: "split_binary_invalid_argument_2", - expr: "'42'.split('2', '1') == ['4']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, string)'\n | '42'.split('2', '1') == ['4']\n | ..........^", - }, - { - original: { - name: "split_ternary_invalid_argument", - expr: "'42'.split('2', 1, 1) == ['4']", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, int, int)'\n | '42'.split('2', 1, 1) == ['4']\n | ..........^", - }, - { - original: { - name: "substring_ternary_invalid_argument", - expr: "'hello'.substring(1, 2, 3) == ''", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "hello"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:18: found no matching overload for 'substring' applied to 'string.(int, int, int)'\n | 'hello'.substring(1, 2, 3) == ''\n | .................^", - }, - { - original: { - name: "substring_binary_invalid_type", - expr: "30.substring(true, 3) == ''", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n 30^#*expr.Constant_Int64Value#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'substring' applied to 'int.(bool, int)'\n | 30.substring(true, 3) == ''\n | ............^", - }, - { - original: { - name: "substring_binary_invalid_argument", - expr: "'tacocat'.substring(true, 3) == ''", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(bool, int)'\n | 'tacocat'.substring(true, 3) == ''\n | ...................^", - }, - { - original: { - name: "substring_binary_invalid_argument_2", - expr: "'tacocat'.substring(0, false) == ''", - disableCheck: true, - evalError: { errors: [{ message: "no such overload" }] }, - }, - ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - error: - "ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(int, bool)'\n | 'tacocat'.substring(0, false) == ''\n | ...................^", - }, - ], - }, - ], - }, - { - name: "timestamps", - suites: [ - { - name: "timestamp_conversions", - tests: [ - { - original: { - name: "toInt_timestamp", - expr: "int(timestamp('2009-02-13T23:31:30Z'))", - value: { int64Value: "1234567890" }, - }, - ast: 'int(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'int(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64', - type: "int", - }, - { - original: { - name: "toString_timestamp", - expr: "string(timestamp('2009-02-13T23:31:30Z'))", - value: { stringValue: "2009-02-13T23:31:30Z" }, - }, - ast: 'string(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'string(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string', - type: "string", - }, - { - original: { - name: "toString_timestamp_nanos", - expr: "string(timestamp('9999-12-31T23:59:59.999999999Z'))", - value: { stringValue: "9999-12-31T23:59:59.999999999Z" }, - }, - ast: 'string(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'string(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string', - type: "string", - }, - { - original: { - name: "toType_timestamp", - expr: "type(timestamp('2009-02-13T23:31:30Z'))", - value: { typeValue: "google.protobuf.Timestamp" }, - }, - ast: 'type(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'type(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~type(timestamp)^type', - type: "type(timestamp)", - }, - { - original: { - name: "type_comparison", - expr: "google.protobuf.Timestamp == type(timestamp('2009-02-13T23:31:30Z'))", - value: { boolValue: true }, - }, - ast: '_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Timestamp^#*expr.Expr_SelectExpr#,\n type(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n google.protobuf.Timestamp~type(timestamp)^google.protobuf.Timestamp,\n type(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n )~type(timestamp)^type\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "duration_conversions", - tests: [ - { - original: { - name: "toString_duration", - expr: "string(duration('1000000s'))", - value: { stringValue: "1000000s" }, - }, - ast: 'string(\n duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'string(\n duration(\n "1000000s"~string\n )~duration^string_to_duration\n)~string^duration_to_string', - type: "string", - }, - { - original: { - name: "toType_duration", - expr: "type(duration('1000000s'))", - value: { typeValue: "google.protobuf.Duration" }, - }, - ast: 'type(\n duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'type(\n duration(\n "1000000s"~string\n )~duration^string_to_duration\n)~type(duration)^type', - type: "type(duration)", - }, - { - original: { - name: "type_comparison", - expr: "google.protobuf.Duration == type(duration('1000000s'))", - value: { boolValue: true }, - }, - ast: '_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Duration^#*expr.Expr_SelectExpr#,\n type(\n duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n google.protobuf.Duration~type(duration)^google.protobuf.Duration,\n type(\n duration(\n "1000000s"~string\n )~duration^string_to_duration\n )~type(duration)^type\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "timestamp_selectors", - tests: [ - { - original: { - name: "getDate", - expr: "timestamp('2009-02-13T23:31:30Z').getDate()", - value: { int64Value: "13" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDate()~int^timestamp_to_day_of_month_1_based', - type: "int", - }, - { - original: { - name: "getDayOfMonth", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfMonth()", - value: { int64Value: "12" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth()~int^timestamp_to_day_of_month', - type: "int", - }, - { - original: { - name: "getDayOfWeek", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfWeek()", - value: { int64Value: "5" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfWeek()~int^timestamp_to_day_of_week', - type: "int", - }, - { - original: { - name: "getDayOfYear", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfYear()", - value: { int64Value: "43" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfYear()~int^timestamp_to_day_of_year', - type: "int", - }, - { - original: { - name: "getFullYear", - expr: "timestamp('2009-02-13T23:31:30Z').getFullYear()", - value: { int64Value: "2009" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getFullYear()~int^timestamp_to_year', - type: "int", - }, - { - original: { - name: "getHours", - expr: "timestamp('2009-02-13T23:31:30Z').getHours()", - value: { int64Value: "23" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getHours()~int^timestamp_to_hours', - type: "int", - }, - { - original: { - name: "getMilliseconds", - expr: "timestamp('2009-02-13T23:31:20.123456789Z').getMilliseconds()", - value: { int64Value: "123" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:20.123456789Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMilliseconds()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:20.123456789Z"~string\n)~timestamp^string_to_timestamp.getMilliseconds()~int^timestamp_to_milliseconds', - type: "int", - }, - { - original: { - name: "getMinutes", - expr: "timestamp('2009-02-13T23:31:30Z').getMinutes()", - value: { int64Value: "31" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMinutes()~int^timestamp_to_minutes', - type: "int", - }, - { - original: { - name: "getMonth", - expr: "timestamp('2009-02-13T23:31:30Z').getMonth()", - value: { int64Value: "1" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMonth()~int^timestamp_to_month', - type: "int", - }, - { - original: { - name: "getSeconds", - expr: "timestamp('2009-02-13T23:31:30Z').getSeconds()", - value: { int64Value: "30" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getSeconds()~int^timestamp_to_seconds', - type: "int", - }, - ], - }, - { - name: "timestamp_selectors_tz", - tests: [ - { - original: { - name: "getDate", - expr: "timestamp('2009-02-13T23:31:30Z').getDate('Australia/Sydney')", - value: { int64Value: "14" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate(\n "Australia/Sydney"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDate(\n "Australia/Sydney"~string\n)~int^timestamp_to_day_of_month_1_based_with_tz', - type: "int", - }, - { - original: { - name: "getDayOfMonth_name_pos", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfMonth('US/Central')", - value: { int64Value: "12" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "US/Central"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "US/Central"~string\n)~int^timestamp_to_day_of_month_with_tz', - type: "int", - }, - { - original: { - name: "getDayOfMonth_numerical_pos", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfMonth('+11:00')", - value: { int64Value: "13" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "+11:00"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "+11:00"~string\n)~int^timestamp_to_day_of_month_with_tz', - type: "int", - }, - { - original: { - name: "getDayOfMonth_numerical_neg", - expr: "timestamp('2009-02-13T02:00:00Z').getDayOfMonth('-02:30')", - value: { int64Value: "11" }, - }, - ast: 'timestamp(\n "2009-02-13T02:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "-02:30"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T02:00:00Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "-02:30"~string\n)~int^timestamp_to_day_of_month_with_tz', - type: "int", - }, - { - original: { - name: "getDayOfMonth_name_neg", - expr: "timestamp('2009-02-13T02:00:00Z').getDayOfMonth('America/St_Johns')", - value: { int64Value: "11" }, - }, - ast: 'timestamp(\n "2009-02-13T02:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "America/St_Johns"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T02:00:00Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "America/St_Johns"~string\n)~int^timestamp_to_day_of_month_with_tz', - type: "int", - }, - { - original: { - name: "getDayOfWeek", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfWeek('UTC')", - value: { int64Value: "5" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek(\n "UTC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfWeek(\n "UTC"~string\n)~int^timestamp_to_day_of_week_with_tz', - type: "int", - }, - { - original: { - name: "getDayOfYear", - expr: "timestamp('2009-02-13T23:31:30Z').getDayOfYear('US/Central')", - value: { int64Value: "43" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear(\n "US/Central"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfYear(\n "US/Central"~string\n)~int^timestamp_to_day_of_year_with_tz', - type: "int", - }, - { - original: { - name: "getFullYear", - expr: "timestamp('2009-02-13T23:31:30Z').getFullYear('-09:30')", - value: { int64Value: "2009" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear(\n "-09:30"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getFullYear(\n "-09:30"~string\n)~int^timestamp_to_year_with_tz', - type: "int", - }, - { - original: { - name: "getHours", - expr: "timestamp('2009-02-13T23:31:30Z').getHours('02:00')", - value: { int64Value: "1" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours(\n "02:00"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getHours(\n "02:00"~string\n)~int^timestamp_to_hours_with_tz', - type: "int", - }, - { - original: { - name: "getMinutes", - expr: "timestamp('2009-02-13T23:31:30Z').getMinutes('Asia/Kathmandu')", - value: { int64Value: "16" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes(\n "Asia/Kathmandu"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMinutes(\n "Asia/Kathmandu"~string\n)~int^timestamp_to_minutes_with_tz', - type: "int", - }, - { - original: { - name: "getMonth", - expr: "timestamp('2009-02-13T23:31:30Z').getMonth('UTC')", - value: { int64Value: "1" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth(\n "UTC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMonth(\n "UTC"~string\n)~int^timestamp_to_month_with_tz', - type: "int", - }, - { - original: { - name: "getSeconds", - expr: "timestamp('2009-02-13T23:31:30Z').getSeconds('-00:00')", - value: { int64Value: "30" }, - }, - ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds(\n "-00:00"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getSeconds(\n "-00:00"~string\n)~int^timestamp_to_seconds_tz', - type: "int", - }, - ], - }, - { - name: "timestamp_equality", - tests: [ - { - original: { - name: "eq_same", - expr: "timestamp('2009-02-13T23:31:30Z') == timestamp('2009-02-13T23:31:30Z')", - value: { boolValue: true }, - }, - ast: '_==_(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_diff", - expr: "timestamp('2009-02-13T23:31:29Z') == timestamp('2009-02-13T23:31:30Z')", - value: { boolValue: false }, - }, - ast: '_==_(\n timestamp(\n "2009-02-13T23:31:29Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n timestamp(\n "2009-02-13T23:31:29Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "neq_same", - expr: "timestamp('1945-05-07T02:41:00Z') != timestamp('1945-05-07T02:41:00Z')", - value: { boolValue: false }, - }, - ast: '_!=_(\n timestamp(\n "1945-05-07T02:41:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "1945-05-07T02:41:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n timestamp(\n "1945-05-07T02:41:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "1945-05-07T02:41:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "neq_diff", - expr: "timestamp('2000-01-01T00:00:00Z') != timestamp('2001-01-01T00:00:00Z')", - value: { boolValue: true }, - }, - ast: '_!=_(\n timestamp(\n "2000-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n timestamp(\n "2000-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals', - type: "bool", - }, - ], - }, - { - name: "duration_equality", - tests: [ - { - original: { - name: "eq_same", - expr: "duration('123s') == duration('123s')", - value: { boolValue: true }, - }, - ast: '_==_(\n duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n duration(\n "123s"~string\n )~duration^string_to_duration,\n duration(\n "123s"~string\n )~duration^string_to_duration\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "eq_diff", - expr: "duration('60s') == duration('3600s')", - value: { boolValue: false }, - }, - ast: '_==_(\n duration(\n "60s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "3600s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n duration(\n "60s"~string\n )~duration^string_to_duration,\n duration(\n "3600s"~string\n )~duration^string_to_duration\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "neq_same", - expr: "duration('604800s') != duration('604800s')", - value: { boolValue: false }, - }, - ast: '_!=_(\n duration(\n "604800s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "604800s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n duration(\n "604800s"~string\n )~duration^string_to_duration,\n duration(\n "604800s"~string\n )~duration^string_to_duration\n)~bool^not_equals', - type: "bool", - }, - { - original: { - name: "neq_diff", - expr: "duration('86400s') != duration('86164s')", - value: { boolValue: true }, - }, - ast: '_!=_(\n duration(\n "86400s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "86164s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_!=_(\n duration(\n "86400s"~string\n )~duration^string_to_duration,\n duration(\n "86164s"~string\n )~duration^string_to_duration\n)~bool^not_equals', - type: "bool", - }, - ], - }, - { - name: "timestamp_arithmetic", - tests: [ - { - original: { - name: "add_duration_to_time", - expr: "timestamp('2009-02-13T23:00:00Z') + duration('240s') == timestamp('2009-02-13T23:04:00Z')", - value: { boolValue: true }, - }, - ast: '_==_(\n _+_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "240s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:04:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _+_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "240s"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n "2009-02-13T23:04:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "add_time_to_duration", - expr: "duration('120s') + timestamp('2009-02-13T23:01:00Z') == timestamp('2009-02-13T23:03:00Z')", - value: { boolValue: true }, - }, - ast: '_==_(\n _+_(\n duration(\n "120s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:01:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:03:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _+_(\n duration(\n "120s"~string\n )~duration^string_to_duration,\n timestamp(\n "2009-02-13T23:01:00Z"~string\n )~timestamp^string_to_timestamp\n )~timestamp^add_duration_timestamp,\n timestamp(\n "2009-02-13T23:03:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "add_duration_to_duration", - expr: "duration('600s') + duration('50s') == duration('650s')", - value: { boolValue: true }, - }, - ast: '_==_(\n _+_(\n duration(\n "600s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "50s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "650s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _+_(\n duration(\n "600s"~string\n )~duration^string_to_duration,\n duration(\n "50s"~string\n )~duration^string_to_duration\n )~duration^add_duration_duration,\n duration(\n "650s"~string\n )~duration^string_to_duration\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "add_time_to_duration_nanos_negative", - expr: "timestamp('0001-01-01T00:00:01.000000001Z') + duration('-999999999ns') == timestamp('0001-01-01T00:00:00.000000002Z')", - value: { boolValue: true }, - }, - ast: '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.000000001Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-999999999ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "0001-01-01T00:00:00.000000002Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.000000001Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "-999999999ns"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n "0001-01-01T00:00:00.000000002Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "add_time_to_duration_nanos_positive", - expr: "timestamp('0001-01-01T00:00:01.999999999Z') + duration('999999999ns') == timestamp('0001-01-01T00:00:02.999999998Z')", - value: { boolValue: true }, - }, - ast: '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "999999999ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "0001-01-01T00:00:02.999999998Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.999999999Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "999999999ns"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n "0001-01-01T00:00:02.999999998Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "subtract_duration_from_time", - expr: "timestamp('2009-02-13T23:10:00Z') - duration('600s') == timestamp('2009-02-13T23:00:00Z')", - value: { boolValue: true }, - }, - ast: '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:10:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "600s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:10:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "600s"~string\n )~duration^string_to_duration\n )~timestamp^subtract_timestamp_duration,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "subtract_time_from_time", - expr: "timestamp('2009-02-13T23:31:00Z') - timestamp('2009-02-13T23:29:00Z') == duration('120s')", - value: { boolValue: true }, - }, - ast: '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:31:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:29:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "120s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:31:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:29:00Z"~string\n )~timestamp^string_to_timestamp\n )~duration^subtract_timestamp_timestamp,\n duration(\n "120s"~string\n )~duration^string_to_duration\n)~bool^equals', - type: "bool", - }, - { - original: { - name: "subtract_duration_from_duration", - expr: "duration('900s') - duration('42s') == duration('858s')", - value: { boolValue: true }, - }, - ast: '_==_(\n _-_(\n duration(\n "900s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "42s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "858s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_==_(\n _-_(\n duration(\n "900s"~string\n )~duration^string_to_duration,\n duration(\n "42s"~string\n )~duration^string_to_duration\n )~duration^subtract_duration_duration,\n duration(\n "858s"~string\n )~duration^string_to_duration\n)~bool^equals', - type: "bool", - }, - ], - }, - { - name: "comparisons", - tests: [ - { - original: { - name: "leq_timestamp_true", - expr: "timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T23:00:00Z')", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp', - type: "bool", - }, - { - original: { - name: "leq_timestamp_false", - expr: "timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T22:59:59Z')", - value: { boolValue: false }, - }, - ast: '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T22:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T22:59:59Z"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp', - type: "bool", - }, - { - original: { - name: "leq_duration_true", - expr: "duration('200s') \u003c= duration('200s')", - value: { boolValue: true }, - }, - ast: '_\u003c=_(\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n duration(\n "200s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration', - type: "bool", - }, - { - original: { - name: "leq_duration_false", - expr: "duration('300s') \u003c= duration('200s')", - value: { boolValue: false }, - }, - ast: '_\u003c=_(\n duration(\n "300s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c=_(\n duration(\n "300s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration', - type: "bool", - }, - { - original: { - name: "less_timestamp_true", - expr: "timestamp('2009-02-13T23:00:00Z') \u003c timestamp('2009-03-13T23:00:00Z')", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-03-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-03-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^less_timestamp', - type: "bool", - }, - { - original: { - name: "less_duration_true", - expr: "duration('200s') \u003c duration('300s')", - value: { boolValue: true }, - }, - ast: '_\u003c_(\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "300s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003c_(\n duration(\n "200s"~string\n )~duration^string_to_duration,\n duration(\n "300s"~string\n )~duration^string_to_duration\n)~bool^less_duration', - type: "bool", - }, - { - original: { - name: "geq_timestamp_true", - expr: "timestamp('2009-02-13T23:00:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp', - type: "bool", - }, - { - original: { - name: "geq_timestamp_false", - expr: "timestamp('2009-02-13T22:58:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n timestamp(\n "2009-02-13T22:58:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n timestamp(\n "2009-02-13T22:58:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp', - type: "bool", - }, - { - original: { - name: "geq_duration_true", - expr: "duration('200s') \u003e= duration('200s')", - value: { boolValue: true }, - }, - ast: '_\u003e=_(\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n duration(\n "200s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration', - type: "bool", - }, - { - original: { - name: "geq_duration_false", - expr: "duration('120s') \u003e= duration('200s')", - value: { boolValue: false }, - }, - ast: '_\u003e=_(\n duration(\n "120s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e=_(\n duration(\n "120s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration', - type: "bool", - }, - { - original: { - name: "greater_timestamp_true", - expr: "timestamp('2009-02-13T23:59:00Z') \u003e timestamp('2009-02-13T23:00:00Z')", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n timestamp(\n "2009-02-13T23:59:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n timestamp(\n "2009-02-13T23:59:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_timestamp', - type: "bool", - }, - { - original: { - name: "greater_duration_true", - expr: "duration('300s') \u003e duration('200s')", - value: { boolValue: true }, - }, - ast: '_\u003e_(\n duration(\n "300s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_\u003e_(\n duration(\n "300s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^greater_duration', - type: "bool", - }, - ], - }, - { - name: "duration_converters", - tests: [ - { - original: { - name: "get_hours", - expr: "duration('10000s').getHours()", - value: { int64Value: "2" }, - }, - ast: 'duration(\n "10000s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#', - checkedAst: - 'duration(\n "10000s"~string\n)~duration^string_to_duration.getHours()~int^duration_to_hours', - type: "int", - }, - { - original: { - name: "get_milliseconds", - description: - "Obtain the milliseconds component of the duration. Note, this is not the same as converting the duration to milliseconds. This behavior will be deprecated.", - expr: "x.getMilliseconds()", - typeEnv: [ - { - name: "x", - ident: { - type: { messageType: "google.protobuf.Duration" }, - }, - }, - ], - bindings: { - x: { - value: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Duration", - value: "123.321456789s", - }, - }, - }, - }, - value: { int64Value: "321" }, - }, - ast: "x^#*expr.Expr_IdentExpr#.getMilliseconds()^#*expr.Expr_CallExpr#", - checkedAst: - "x~duration^x.getMilliseconds()~int^duration_to_milliseconds", - type: "int", - }, - { - original: { - name: "get_minutes", - expr: "duration('3730s').getMinutes()", - value: { int64Value: "62" }, - }, - ast: 'duration(\n "3730s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#', - checkedAst: - 'duration(\n "3730s"~string\n)~duration^string_to_duration.getMinutes()~int^duration_to_minutes', - type: "int", - }, - { - original: { - name: "get_seconds", - expr: "duration('3730s').getSeconds()", - value: { int64Value: "3730" }, - }, - ast: 'duration(\n "3730s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#', - checkedAst: - 'duration(\n "3730s"~string\n)~duration^string_to_duration.getSeconds()~int^duration_to_seconds', - type: "int", - }, - ], - }, - { - name: "timestamp_range", - tests: [ - { - original: { - name: "from_string_under", - expr: "timestamp('0000-01-01T00:00:00Z')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: 'timestamp(\n "0000-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "0000-01-01T00:00:00Z"~string\n)~timestamp^string_to_timestamp', - type: "timestamp", - }, - { - original: { - name: "from_string_over", - expr: "timestamp('10000-01-01T00:00:00Z')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: 'timestamp(\n "10000-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'timestamp(\n "10000-01-01T00:00:00Z"~string\n)~timestamp^string_to_timestamp', - type: "timestamp", - }, - { - original: { - name: "add_duration_under", - expr: "timestamp('0001-01-01T00:00:00Z') + duration('-1s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-1s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "-1s"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', - type: "timestamp", - }, - { - original: { - name: "add_duration_over", - expr: "timestamp('9999-12-31T23:59:59Z') + duration('1s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_+_(\n timestamp(\n "9999-12-31T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "1s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n timestamp(\n "9999-12-31T23:59:59Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "1s"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', - type: "timestamp", - }, - { - original: { - name: "add_duration_nanos_over", - expr: "timestamp('9999-12-31T23:59:59.999999999Z') + duration('1ns')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_+_(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "1ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "1ns"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', - type: "timestamp", - }, - { - original: { - name: "add_duration_nanos_under", - expr: "timestamp('0001-01-01T00:00:00Z') + duration('-1ns')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-1ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "-1ns"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', - type: "timestamp", - }, - { - original: { - name: "sub_time_duration_over", - expr: "timestamp('9999-12-31T23:59:59Z') - timestamp('0001-01-01T00:00:00Z')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_-_(\n timestamp(\n "9999-12-31T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_-_(\n timestamp(\n "9999-12-31T23:59:59Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp', - type: "duration", - }, - { - original: { - name: "sub_time_duration_under", - expr: "timestamp('0001-01-01T00:00:00Z') - timestamp('9999-12-31T23:59:59Z')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_-_(\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "9999-12-31T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_-_(\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "9999-12-31T23:59:59Z"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp', - type: "duration", - }, - ], - }, - { - name: "duration_range", - tests: [ - { - original: { - name: "from_string_under", - expr: "duration('-320000000000s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: 'duration(\n "-320000000000s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'duration(\n "-320000000000s"~string\n)~duration^string_to_duration', - type: "duration", - }, - { - original: { - name: "from_string_over", - expr: "duration('320000000000s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: 'duration(\n "320000000000s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'duration(\n "320000000000s"~string\n)~duration^string_to_duration', - type: "duration", - }, - { - original: { - name: "add_under", - expr: "duration('-200000000000s') + duration('-200000000000s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_+_(\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration', - type: "duration", - }, - { - original: { - name: "add_over", - expr: "duration('200000000000s') + duration('200000000000s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_+_(\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n duration(\n "200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "200000000000s"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration', - type: "duration", - }, - { - original: { - name: "sub_under", - expr: "duration('-200000000000s') - duration('200000000000s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_-_(\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_-_(\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "200000000000s"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration', - type: "duration", - }, - { - original: { - name: "sub_over", - expr: "duration('200000000000s') - duration('-200000000000s')", - evalError: { errors: [{ message: "range" }] }, - }, - ast: '_-_(\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_-_(\n duration(\n "200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration', - type: "duration", - }, - ], - }, - ], - }, - { - name: "type_deductions", - suites: [ - { - name: "constant_literals", - tests: [ - { - original: { - name: "bool", - expr: "true", - typedResult: { - result: { boolValue: true }, - deducedType: { primitive: "BOOL" }, - }, - }, - ast: "true^#*expr.Constant_BoolValue#", - checkedAst: "true~bool", - type: "bool", - }, - { - original: { - name: "int", - expr: "42", - typedResult: { - result: { int64Value: "42" }, - deducedType: { primitive: "INT64" }, - }, - }, - ast: "42^#*expr.Constant_Int64Value#", - checkedAst: "42~int", - type: "int", - }, - { - original: { - name: "uint", - expr: "42u", - typedResult: { - result: { uint64Value: "42" }, - deducedType: { primitive: "UINT64" }, - }, - }, - ast: "42u^#*expr.Constant_Uint64Value#", - checkedAst: "42u~uint", - type: "uint", - }, - { - original: { - name: "double", - expr: "0.1", - typedResult: { - result: { doubleValue: 0.1 }, - deducedType: { primitive: "DOUBLE" }, - }, - }, - ast: "0.1^#*expr.Constant_DoubleValue#", - checkedAst: "0.1~double", - type: "double", - }, - { - original: { - name: "string", - expr: '"test"', - typedResult: { - result: { stringValue: "test" }, - deducedType: { primitive: "STRING" }, - }, - }, - ast: '"test"^#*expr.Constant_StringValue#', - checkedAst: '"test"~string', - type: "string", - }, - { - original: { - name: "bytes", - expr: 'b"test"', - typedResult: { - result: { bytesValue: "dGVzdA==" }, - deducedType: { primitive: "BYTES" }, - }, - }, - ast: 'b"test"^#*expr.Constant_BytesValue#', - checkedAst: 'b"test"~bytes', - type: "bytes", - }, - { - original: { - name: "null", - expr: "null", - typedResult: { - result: { nullValue: null }, - deducedType: { null: null }, - }, - }, - ast: "null^#*expr.Constant_NullValue#", - checkedAst: "null~null", - type: "null", - }, - ], - }, - { - name: "complex_initializers", - tests: [ - { - original: { - name: "list", - expr: "[1]", - typedResult: { - result: { listValue: { values: [{ int64Value: "1" }] } }, - deducedType: { - listType: { elemType: { primitive: "INT64" } }, - }, - }, - }, - ast: "[\n 1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#", - checkedAst: "[\n 1~int\n]~list(int)", - type: "list(int)", - }, - { - original: { - name: "map", - expr: "{'abc': 123}", - typedResult: { - result: { - mapValue: { - entries: [ - { - key: { stringValue: "abc" }, - value: { int64Value: "123" }, - }, - ], - }, - }, - deducedType: { - mapType: { - keyType: { primitive: "STRING" }, - valueType: { primitive: "INT64" }, - }, - }, - }, - }, - ast: '{\n "abc"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', - checkedAst: '{\n "abc"~string:123~int\n}~map(string, int)', - type: "map(string, int)", - }, - { - original: { - name: "struct", - expr: "TestAllTypes{single_int64: 1}", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - singleInt64: "1", - }, - }, - deducedType: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ast: "TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", - type: "cel.expr.conformance.proto3.TestAllTypes", - }, - ], - }, - { - name: "field_access", - tests: [ - { - original: { - name: "int_field", - expr: "TestAllTypes{single_int64: 1}.single_int64", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { int64Value: "1" }, - deducedType: { primitive: "INT64" }, - }, - }, - ast: "TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int", - type: "int", - }, - { - original: { - name: "repeated_int_field", - expr: "TestAllTypes{}.repeated_int64", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { listValue: {} }, - deducedType: { - listType: { elemType: { primitive: "INT64" } }, - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)", - type: "list(int)", - }, - { - original: { - name: "map_bool_int", - expr: "TestAllTypes{}.map_bool_int64", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { mapValue: {} }, - deducedType: { - mapType: { - keyType: { primitive: "BOOL" }, - valueType: { primitive: "INT64" }, - }, - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_bool_int64^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_bool_int64~map(bool, int)", - type: "map(bool, int)", - }, - { - original: { - name: "enum_field", - expr: "TestAllTypes{}.standalone_enum", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { int64Value: "0" }, - deducedType: { primitive: "INT64" }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int", - type: "int", - }, - { - original: { - name: "repeated_enum_field", - expr: "TestAllTypes{}.repeated_nested_enum", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { listValue: {} }, - deducedType: { - listType: { elemType: { primitive: "INT64" } }, - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)", - type: "list(int)", - }, - { - original: { - name: "enum_map_field", - expr: "TestAllTypes{}.map_int32_enum", - container: "cel.expr.conformance.proto3", - typedResult: { - result: { mapValue: {} }, - deducedType: { - mapType: { - keyType: { primitive: "INT64" }, - valueType: { primitive: "INT64" }, - }, - }, - }, - }, - ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_int32_enum^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_int32_enum~map(int, int)", - type: "map(int, int)", - }, - ], - }, - { - name: "indexing", - tests: [ - { - original: { - name: "list", - expr: "['foo'][0]", - typedResult: { - result: { stringValue: "foo" }, - deducedType: { primitive: "STRING" }, - }, - }, - ast: '_[_](\n [\n "foo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n [\n "foo"~string\n ]~list(string),\n 0~int\n)~string^index_list', - type: "string", - }, - { - original: { - name: "map", - expr: "{'abc': 123}['abc']", - typedResult: { - result: { int64Value: "123" }, - deducedType: { primitive: "INT64" }, - }, - }, - ast: '_[_](\n {\n "abc"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_[_](\n {\n "abc"~string:123~int\n }~map(string, int),\n "abc"~string\n)~int^index_map', - type: "int", - }, - ], - }, - { - name: "functions", - tests: [ - { - original: { - name: "nested_calls", - expr: "('foo' + 'bar').startsWith('foo')", - typedResult: { - result: { boolValue: true }, - deducedType: { primitive: "BOOL" }, - }, - }, - ast: '_+_(\n "foo"^#*expr.Constant_StringValue#,\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.startsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', - checkedAst: - '_+_(\n "foo"~string,\n "bar"~string\n)~string^add_string.startsWith(\n "foo"~string\n)~bool^starts_with_string', - type: "bool", - }, - { - original: { - name: "function_result_type", - expr: "fn('abc', 123)", - checkOnly: true, - typeEnv: [ - { - name: "fn", - function: { - overloads: [ - { - overloadId: "fn_string_int", - params: [ - { primitive: "STRING" }, - { primitive: "INT64" }, - ], - resultType: { primitive: "STRING" }, - }, - ], - }, - }, - ], - typedResult: { deducedType: { primitive: "STRING" } }, - }, - ast: 'fn(\n "abc"^#*expr.Constant_StringValue#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', - checkedAst: - 'fn(\n "abc"~string,\n 123~int\n)~string^fn_string_int', - type: "string", - }, - ], - }, - { - name: "flexible_type_parameter_assignment", - tests: [ - { - original: { - name: "list_parameter", - expr: "[[], [[]], [[[]]], [[[[]]]]]", - checkOnly: true, - typedResult: { - deducedType: { - listType: { - elemType: { - listType: { - elemType: { - listType: { - elemType: { - listType: { - elemType: { - listType: { elemType: { dyn: {} } }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - ast: "[\n []^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n []~list(list(list(list(dyn)))),\n [\n []~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))", - type: "list(list(list(list(list(dyn)))))", - }, - { - original: { - name: "list_parameter_order_independent", - expr: "[[[[[]]]], [], [[[]]]]", - checkOnly: true, - typedResult: { - deducedType: { - listType: { - elemType: { - listType: { - elemType: { - listType: { - elemType: { - listType: { - elemType: { - listType: { elemType: { dyn: {} } }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - ast: "[\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n []~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))", - type: "list(list(list(list(list(dyn)))))", - }, - { - original: { - name: "comprehension_type_var_aliasing", - expr: "msg.repeated_nested_message.map(x, x).map(y, y.bb)", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { - deducedType: { - listType: { elemType: { primitive: "INT64" } }, - }, - }, - }, - ast: "__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n y^#*expr.Expr_IdentExpr#.bb^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", - checkedAst: - "__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result,\n [\n x~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^x\n ]~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n // Result\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result)~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n y~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^y.bb~int\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", - type: "list(int)", - }, - { - original: { - name: "overload_type_var_aliasing", - expr: "([] + msg.repeated_nested_message + [])[0].bb", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { deducedType: { primitive: "INT64" } }, - }, - ast: "_[_](\n _+_(\n _+_(\n []^#*expr.Expr_ListExpr#,\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.bb^#*expr.Expr_SelectExpr#", - checkedAst: - "_[_](\n _+_(\n _+_(\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n 0~int\n)~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^index_list.bb~int", - type: "int", - }, - { - original: { - name: "unconstrained_type_var_as_dyn", - expr: "([].map(x,x))[0].foo", - checkOnly: true, - typedResult: { deducedType: { dyn: {} } }, - }, - ast: "_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.foo^#*expr.Expr_SelectExpr#", - checkedAst: - "_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []~list(dyn),\n // Accumulator\n @result,\n // Init\n []~list(dyn),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(dyn)^@result,\n [\n x~dyn^x\n ]~list(dyn)\n )~list(dyn)^add_list,\n // Result\n @result~list(dyn)^@result)~list(dyn),\n 0~int\n)~dyn^index_list.foo~dyn", - type: "dyn", - }, - { - original: { - name: "list_parameters_do_not_unify", - expr: "[msg.single_int64_wrapper, msg.single_string_wrapper]", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { - deducedType: { listType: { elemType: { dyn: {} } } }, - }, - }, - ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_string_wrapper~wrapper(string)\n]~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "optional_none", - expr: "[optional.none(), optional.of(1)]", - checkOnly: true, - typedResult: { - deducedType: { - listType: { - elemType: { - abstractType: { - name: "optional_type", - parameterTypes: [{ primitive: "INT64" }], - }, - }, - }, - }, - }, - }, - ast: "[\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(int))", - type: "list(optional_type(int))", - }, - { - original: { - name: "optional_none_2", - expr: "[optional.of(1), optional.none()]", - checkOnly: true, - typedResult: { - deducedType: { - listType: { - elemType: { - abstractType: { - name: "optional_type", - parameterTypes: [{ primitive: "INT64" }], - }, - }, - }, - }, - }, - }, - ast: "[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n]~list(optional_type(int))", - type: "list(optional_type(int))", - }, - { - original: { - name: "optional_dyn_promotion", - expr: "[optional.of(1), optional.of(dyn(1))]", - checkOnly: true, - typedResult: { - deducedType: { - listType: { - elemType: { - abstractType: { - name: "optional_type", - parameterTypes: [{ dyn: {} }], - }, - }, - }, - }, - }, - }, - ast: "[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of\n]~list(optional_type(dyn))", - type: "list(optional_type(dyn))", - }, - { - original: { - name: "optional_dyn_promotion_2", - expr: "[optional.of(dyn(1)), optional.of(1)]", - checkOnly: true, - typedResult: { - deducedType: { - listType: { - elemType: { - abstractType: { - name: "optional_type", - parameterTypes: [{ dyn: {} }], - }, - }, - }, - }, - }, - }, - ast: "[\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(dyn))", - type: "list(optional_type(dyn))", - }, - { - original: { - name: "optional_in_ternary", - expr: "true ? optional.of(dyn(1)) : optional.of(1)", - checkOnly: true, - typedResult: { - deducedType: { - abstractType: { - name: "optional_type", - parameterTypes: [{ dyn: {} }], - }, - }, - }, - }, - ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n true~bool,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~optional_type(dyn)^conditional", - type: "optional_type(dyn)", - }, - ], - }, - { - name: "wrappers", - tests: [ - { - original: { - name: "wrapper_promotion", - expr: "[msg.single_int64_wrapper, msg.single_int64]", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { - deducedType: { listType: { elemType: { wrapper: "INT64" } } }, - }, - }, - ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(wrapper(int))", - type: "list(wrapper(int))", - }, - { - original: { - name: "wrapper_promotion_2", - expr: "[msg.single_int64, msg.single_int64_wrapper]", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { - deducedType: { listType: { elemType: { wrapper: "INT64" } } }, - }, - }, - ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int)\n]~list(int)", - type: "list(int)", - }, - { - original: { - name: "wrapper_dyn_promotion", - expr: "[msg.single_int64_wrapper, msg.single_int64, dyn(1)]", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { - deducedType: { listType: { elemType: { dyn: {} } } }, - }, - }, - ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n dyn(\n 1~int\n )~dyn^to_dyn\n]~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "wrapper_dyn_promotion_2", - expr: "[dyn(1), msg.single_int64_wrapper, msg.single_int64]", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { - deducedType: { listType: { elemType: { dyn: {} } } }, - }, - }, - ast: "[\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", - checkedAst: - "[\n dyn(\n 1~int\n )~dyn^to_dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(dyn)", - type: "list(dyn)", - }, - { - original: { - name: "wrapper_primitive_assignable", - expr: "msg.single_int64_wrapper + 1", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { deducedType: { primitive: "INT64" } }, - }, - ast: "_+_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_+_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 1~int\n)~int^add_int64", - type: "int", - }, - { - original: { - name: "wrapper_null_assignable", - expr: "msg.single_int64_wrapper == null", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { deducedType: { primitive: "BOOL" } }, - }, - ast: "_==_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "wrapper_ternary_parameter_assignment", - expr: "false ? msg.single_int64_wrapper : null", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { deducedType: { wrapper: "INT64" } }, - }, - ast: "_?_:_(\n false^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n false~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~wrapper(int)^conditional", - type: "wrapper(int)", - }, - { - original: { - name: "wrapper_ternary_parameter_assignment_2", - expr: "true ? msg.single_int64_wrapper : 42", - checkOnly: true, - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - typedResult: { deducedType: { wrapper: "INT64" } }, - }, - ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_?_:_(\n true~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 42~int\n)~wrapper(int)^conditional", - type: "wrapper(int)", - }, - ], - }, - { - name: "type_parameters", - tests: [ - { - original: { - name: "multiple_parameters_generality", - expr: "[tuple(1, 2u, 3.0), tuple(dyn(1), dyn(2u), dyn(3.0))][0]", - checkOnly: true, - typeEnv: [ - { - name: "tuple", - function: { - overloads: [ - { - overloadId: "tuple_T_U_V", - params: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - resultType: { - abstractType: { - name: "tuple", - parameterTypes: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - }, - }, - }, - ], - }, - }, - ], - typedResult: { - deducedType: { - abstractType: { - name: "tuple", - parameterTypes: [{ dyn: {} }, { dyn: {} }, { dyn: {} }], - }, - }, - }, - }, - ast: "_[_](\n [\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(dyn, dyn, dyn)^tuple_T_U_V\n ]~list(tuple(dyn, dyn, dyn)),\n 0~int\n)~tuple(dyn, dyn, dyn)^index_list", - type: "tuple(dyn, dyn, dyn)", - }, - { - original: { - name: "multiple_parameters_generality_2", - expr: "sort(tuple(dyn(1), 2u, 3.0))", - checkOnly: true, - typeEnv: [ - { - name: "tuple", - function: { - overloads: [ - { - overloadId: "tuple_T_U_V", - params: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - resultType: { - abstractType: { - name: "tuple", - parameterTypes: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - }, - }, - }, - ], - }, - }, - { - name: "sort", - function: { - overloads: [ - { - overloadId: "sort_tuple_T_T_T", - params: [ - { - abstractType: { - name: "tuple", - parameterTypes: [ - { typeParam: "T" }, - { typeParam: "T" }, - { typeParam: "T" }, - ], - }, - }, - ], - resultType: { - abstractType: { - name: "tuple", - parameterTypes: [ - { typeParam: "T" }, - { typeParam: "T" }, - { typeParam: "T" }, - ], - }, - }, - }, - ], - }, - }, - ], - typedResult: { - deducedType: { - abstractType: { - name: "tuple", - parameterTypes: [{ dyn: {} }, { dyn: {} }, { dyn: {} }], - }, - }, - }, - }, - ast: "sort(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "sort(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint,\n 3~double\n )~tuple(dyn, uint, double)^tuple_T_U_V\n)~tuple(dyn, dyn, dyn)^sort_tuple_T_T_T", - type: "tuple(dyn, dyn, dyn)", - }, - { - original: { - name: "multiple_parameters_parameterized_ovl", - expr: "tuple(1, 2u, 3.0) == tuple(1, dyn(2u), dyn(3.0))", - checkOnly: true, - typeEnv: [ - { - name: "tuple", - function: { - overloads: [ - { - overloadId: "tuple_T_U_V", - params: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - resultType: { - abstractType: { - name: "tuple", - parameterTypes: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - }, - }, - }, - ], - }, - }, - ], - typedResult: { deducedType: { primitive: "BOOL" } }, - }, - ast: "_==_(\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n 1~int,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(int, dyn, dyn)^tuple_T_U_V\n)~bool^equals", - type: "bool", - }, - { - original: { - name: "multiple_parameters_parameterized_ovl_2", - expr: "tuple(dyn(1), dyn(2u), 3.0) == tuple(1, 2u, 3.0)", - checkOnly: true, - typeEnv: [ - { - name: "tuple", - function: { - overloads: [ - { - overloadId: "tuple_T_U_V", - params: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - resultType: { - abstractType: { - name: "tuple", - parameterTypes: [ - { typeParam: "T" }, - { typeParam: "U" }, - { typeParam: "V" }, - ], - }, - }, - }, - ], - }, - }, - ], - typedResult: { deducedType: { primitive: "BOOL" } }, - }, - ast: "_==_(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 3~double\n )~tuple(dyn, dyn, double)^tuple_T_U_V,\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "legacy_nullable_types", - tests: [ - { - original: { - name: "null_assignable_to_message_parameter_candidate", - expr: "[msg, null][0]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - }, - typedResult: { - result: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - }, - }, - deducedType: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ast: "_[_](\n [\n msg^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", - type: "null", - }, - { - original: { - name: "null_assignable_to_duration_parameter_candidate", - expr: "[msg.single_duration, null][0]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - }, - typedResult: { - result: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Duration", - value: "0s", - }, - }, - deducedType: { wellKnown: "DURATION" }, - }, - }, - ast: "_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_duration^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_duration~duration,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", - type: "null", - }, - { - original: { - name: "null_assignable_to_timestamp_parameter_candidate", - expr: "[msg.single_timestamp, null][0]", - typeEnv: [ - { - name: "msg", - ident: { - type: { - messageType: "cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - ], - bindings: { - msg: { - value: { - objectValue: { - "@type": - "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", - }, - }, - }, - }, - typedResult: { - result: { - objectValue: { - "@type": "type.googleapis.com/google.protobuf.Timestamp", - value: "1970-01-01T00:00:00Z", - }, - }, - deducedType: { wellKnown: "TIMESTAMP" }, - }, - }, - ast: "_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_timestamp^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_timestamp~timestamp,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", - type: "null", - }, - { - original: { - name: "null_assignable_to_abstract_parameter_candidate", - expr: "[optional.of(1), null][0]", - checkOnly: true, - typedResult: { - deducedType: { - abstractType: { - name: "optional_type", - parameterTypes: [{ primitive: "INT64" }], - }, - }, - }, - }, - ast: "_[_](\n [\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_[_](\n [\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", - type: "null", - }, - ], - }, - ], - }, - { name: "unknowns" }, - { - name: "wrappers", - suites: [ - { - name: "bool", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.BoolValue{value: true}}.single_any", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.BoolValue{value: true}}.single_value", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_bool_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_bool_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "int32", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.Int32Value{value: 1}}.single_any", - container: "cel.expr.conformance.proto3", - value: { int64Value: "1" }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.Int32Value{value: 1}}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_int32_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_int32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "int64", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.Int64Value{value: 1}}.single_any", - container: "cel.expr.conformance.proto3", - value: { int64Value: "1" }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json_number", - expr: "TestAllTypes{single_value: google.protobuf.Int64Value{value: 1}}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_json_string", - expr: "TestAllTypes{single_value: google.protobuf.Int64Value{value: 9223372036854775807}}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "9223372036854775807" }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_int64_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_int64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "uint32", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.UInt32Value{value: 1u}}.single_any", - container: "cel.expr.conformance.proto3", - value: { uint64Value: "1" }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.UInt32Value{value: 1u}}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_uint32_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_uint32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "uint64", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.UInt64Value{value: 1u}}.single_any", - container: "cel.expr.conformance.proto3", - value: { uint64Value: "1" }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json_number", - expr: "TestAllTypes{single_value: google.protobuf.UInt64Value{value: 1u}}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_json_string", - expr: "TestAllTypes{single_value: google.protobuf.UInt64Value{value: 18446744073709551615u}}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "18446744073709551615" }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_uint64_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_uint64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "float", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.FloatValue{value: 1.0}}.single_any", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.FloatValue{value: 1.0}}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_float_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_float_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "double", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.DoubleValue{value: 1.0}}.single_any", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.DoubleValue{value: 1.0}}.single_value", - container: "cel.expr.conformance.proto3", - value: { doubleValue: 1 }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_double_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_double_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "bytes", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.BytesValue{value: b'foo'}}.single_any", - container: "cel.expr.conformance.proto3", - value: { bytesValue: "Zm9v" }, - }, - ast: 'TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b"foo"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b"foo"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any', - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.BytesValue{value: b'foo'}}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "Zm9v" }, - }, - ast: 'TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b"foo"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b"foo"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_bytes_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_bytes_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "string", - tests: [ - { - original: { - name: "to_any", - expr: "TestAllTypes{single_any: google.protobuf.StringValue{value: 'foo'}}.single_any", - container: "cel.expr.conformance.proto3", - value: { stringValue: "foo" }, - }, - ast: 'TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:"foo"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any', - type: "any", - }, - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.StringValue{value: 'foo'}}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "foo" }, - }, - ast: 'TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:"foo"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - { - original: { - name: "to_null", - expr: "TestAllTypes{single_string_wrapper: null} == TestAllTypes{}", - container: "cel.expr.conformance.proto3", - value: { boolValue: true }, - }, - ast: "_==_(\n TestAllTypes{\n single_string_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", - checkedAst: - "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", - type: "bool", - }, - ], - }, - { - name: "value", - tests: [ - { - original: { - name: "default_to_json", - expr: "TestAllTypes{single_any: TestAllTypes{}.single_value}.single_any", - container: "cel.expr.conformance.proto3", - value: { nullValue: null }, - }, - ast: "TestAllTypes{\n single_any:TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - ], - }, - { - name: "list_value", - tests: [ - { - original: { - name: "literal_to_any", - expr: "TestAllTypes{single_any: []}.single_any", - container: "cel.expr.conformance.proto3", - value: { listValue: {} }, - }, - ast: "TestAllTypes{\n single_any:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - ], - }, - { - name: "struct", - tests: [ - { - original: { - name: "literal_to_any", - expr: "TestAllTypes{single_any: {}}.single_any", - container: "cel.expr.conformance.proto3", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{\n single_any:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_any:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", - type: "any", - }, - ], - }, - { - name: "field_mask", - tests: [ - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.FieldMask{paths: ['foo', 'bar']}}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "foo,bar" }, - }, - ast: 'TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n "foo"^#*expr.Constant_StringValue#,\n "bar"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n "foo"~string,\n "bar"~string\n ]~list(string)\n }~google.protobuf.FieldMask^google.protobuf.FieldMask\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - ], - }, - { - name: "duration", - tests: [ - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: duration('1000000s')}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "1000000s" }, - }, - ast: 'TestAllTypes{\n single_value:duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:duration(\n "1000000s"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - ], - }, - { - name: "timestamp", - tests: [ - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: timestamp('9999-12-31T23:59:59.999999999Z')}.single_value", - container: "cel.expr.conformance.proto3", - value: { stringValue: "9999-12-31T23:59:59.999999999Z" }, - }, - ast: 'TestAllTypes{\n single_value:timestamp(\n "9999-12-31T23:59:59.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', - checkedAst: - 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:timestamp(\n "9999-12-31T23:59:59.999999999Z"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', - type: "dyn", - }, - ], - }, - { - name: "empty", - tests: [ - { - original: { - name: "to_json", - expr: "TestAllTypes{single_value: google.protobuf.Empty{}}.single_value", - container: "cel.expr.conformance.proto3", - value: { mapValue: {} }, - }, - ast: "TestAllTypes{\n single_value:google.protobuf.Empty{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", - checkedAst: - "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Empty{}~google.protobuf.Empty^google.protobuf.Empty\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", - type: "dyn", - }, - ], - }, - ], - }, - ], -} as const; +import type { SerializedIncrementalTestSuite } from './tests.js';export const tests: SerializedIncrementalTestSuite = {"name":"conformance","suites":[{"name":"basic","suites":[{"name":"self_eval_zeroish","tests":[{"original":{"name":"self_eval_int_zero","expr":"0","value":{"int64Value":"0"}},"ast":"0^#*expr.Constant_Int64Value#","checkedAst":"0~int","type":"int"},{"original":{"name":"self_eval_uint_zero","expr":"0u","value":{"uint64Value":"0"}},"ast":"0u^#*expr.Constant_Uint64Value#","checkedAst":"0u~uint","type":"uint"},{"original":{"name":"self_eval_uint_alias_zero","expr":"0U","value":{"uint64Value":"0"}},"ast":"0u^#*expr.Constant_Uint64Value#","checkedAst":"0u~uint","type":"uint"},{"original":{"name":"self_eval_float_zero","expr":"0.0","value":{"doubleValue":0}},"ast":"0^#*expr.Constant_DoubleValue#","checkedAst":"0~double","type":"double"},{"original":{"name":"self_eval_float_zerowithexp","expr":"0e+0","value":{"doubleValue":0}},"ast":"0^#*expr.Constant_DoubleValue#","checkedAst":"0~double","type":"double"},{"original":{"name":"self_eval_string_empty","expr":"''","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_string_empty_quotes","expr":"\"\"","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_string_raw_prefix","expr":"r\"\"","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_bytes_empty","expr":"b\"\"","value":{"bytesValue":""}},"ast":"b\"\"^#*expr.Constant_BytesValue#","checkedAst":"b\"\"~bytes","type":"bytes"},{"original":{"name":"self_eval_bool_false","expr":"false","value":{"boolValue":false}},"ast":"false^#*expr.Constant_BoolValue#","checkedAst":"false~bool","type":"bool"},{"original":{"name":"self_eval_null","expr":"null","value":{"nullValue":null}},"ast":"null^#*expr.Constant_NullValue#","checkedAst":"null~null","type":"null"},{"original":{"name":"self_eval_empty_list","expr":"[]","value":{"listValue":{}}},"ast":"[]^#*expr.Expr_ListExpr#","checkedAst":"[]~list(dyn)","type":"list(dyn)"},{"original":{"name":"self_eval_empty_map","expr":"{}","value":{"mapValue":{}}},"ast":"{}^#*expr.Expr_StructExpr#","checkedAst":"{}~map(dyn, dyn)","type":"map(dyn, dyn)"},{"original":{"name":"self_eval_string_raw_prefix_triple_double","expr":"r\"\"\"\"\"\"","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_string_raw_prefix_triple_single","expr":"r''''''","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"}]},{"name":"self_eval_nonzeroish","tests":[{"original":{"name":"self_eval_int_nonzero","expr":"42","value":{"int64Value":"42"}},"ast":"42^#*expr.Constant_Int64Value#","checkedAst":"42~int","type":"int"},{"original":{"name":"self_eval_uint_nonzero","expr":"123456789u","value":{"uint64Value":"123456789"}},"ast":"123456789u^#*expr.Constant_Uint64Value#","checkedAst":"123456789u~uint","type":"uint"},{"original":{"name":"self_eval_uint_alias_nonzero","expr":"123456789U","value":{"uint64Value":"123456789"}},"ast":"123456789u^#*expr.Constant_Uint64Value#","checkedAst":"123456789u~uint","type":"uint"},{"original":{"name":"self_eval_int_negative_min","expr":"-9223372036854775808","value":{"int64Value":"-9223372036854775808"}},"ast":"-9223372036854775808^#*expr.Constant_Int64Value#","checkedAst":"-9223372036854775808~int","type":"int"},{"original":{"name":"self_eval_float_negative_exp","expr":"-2.3e+1","value":{"doubleValue":-23}},"ast":"-23^#*expr.Constant_DoubleValue#","checkedAst":"-23~double","type":"double"},{"original":{"name":"self_eval_string_excl","expr":"\"!\"","value":{"stringValue":"!"}},"ast":"\"!\"^#*expr.Constant_StringValue#","checkedAst":"\"!\"~string","type":"string"},{"original":{"name":"self_eval_string_escape","expr":"'\\''","value":{"stringValue":"'"}},"ast":"\"'\"^#*expr.Constant_StringValue#","checkedAst":"\"'\"~string","type":"string"},{"original":{"name":"self_eval_bytes_escape","expr":"b'ÿ'","value":{"bytesValue":"w78="}},"ast":"b\"ÿ\"^#*expr.Constant_BytesValue#","checkedAst":"b\"ÿ\"~bytes","type":"bytes"},{"original":{"name":"self_eval_bytes_invalid_utf8","expr":"b'\\000\\xff'","value":{"bytesValue":"AP8="}},"ast":"b\"\\x00\\xff\"^#*expr.Constant_BytesValue#","checkedAst":"b\"\\x00\\xff\"~bytes","type":"bytes"},{"original":{"name":"self_eval_list_singleitem","expr":"[-1]","value":{"listValue":{"values":[{"int64Value":"-1"}]}}},"ast":"[\n -1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n -1~int\n]~list(int)","type":"list(int)"},{"original":{"name":"self_eval_map_singleitem","expr":"{\"k\":\"v\"}","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}}]}}},"ast":"{\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"{\n \"k\"~string:\"v\"~string\n}~map(string, string)","type":"map(string, string)"},{"original":{"name":"self_eval_bool_true","expr":"true","value":{"boolValue":true}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"self_eval_int_hex","expr":"0x55555555","value":{"int64Value":"1431655765"}},"ast":"1431655765^#*expr.Constant_Int64Value#","checkedAst":"1431655765~int","type":"int"},{"original":{"name":"self_eval_int_hex_negative","expr":"-0x55555555","value":{"int64Value":"-1431655765"}},"ast":"-1431655765^#*expr.Constant_Int64Value#","checkedAst":"-1431655765~int","type":"int"},{"original":{"name":"self_eval_uint_hex","expr":"0x55555555u","value":{"uint64Value":"1431655765"}},"ast":"1431655765u^#*expr.Constant_Uint64Value#","checkedAst":"1431655765u~uint","type":"uint"},{"original":{"name":"self_eval_uint_alias_hex","expr":"0x55555555U","value":{"uint64Value":"1431655765"}},"ast":"1431655765u^#*expr.Constant_Uint64Value#","checkedAst":"1431655765u~uint","type":"uint"},{"original":{"name":"self_eval_unicode_escape_four","expr":"\"\\u270c\"","value":{"stringValue":"✌"}},"ast":"\"✌\"^#*expr.Constant_StringValue#","checkedAst":"\"✌\"~string","type":"string"},{"original":{"name":"self_eval_unicode_escape_eight","expr":"\"\\U0001f431\"","value":{"stringValue":"🐱"}},"ast":"\"🐱\"^#*expr.Constant_StringValue#","checkedAst":"\"🐱\"~string","type":"string"},{"original":{"name":"self_eval_ascii_escape_seq","expr":"\"\\a\\b\\f\\n\\r\\t\\v\\\"\\'\\\\\"","value":{"stringValue":"\u0007\b\f\n\r\t\u000b\"'\\"}},"ast":"\"\\a\\b\\f\\n\\r\\t\\v\\\"'\\\\\"^#*expr.Constant_StringValue#","checkedAst":"\"\\a\\b\\f\\n\\r\\t\\v\\\"'\\\\\"~string","type":"string"}]},{"name":"variables","tests":[{"original":{"name":"self_eval_bound_lookup","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"123"}}},"value":{"int64Value":"123"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~int^x","type":"int"},{"original":{"name":"self_eval_unbound_lookup","description":"An unbound variable should be marked as an error during execution. See google/cel-go#154","expr":"x","disableCheck":true,"evalError":{"errors":[{"message":"undeclared reference to 'x' (in container '')"}]}},"ast":"x^#*expr.Expr_IdentExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x\n | ^"},{"original":{"name":"unbound_is_runtime_error","description":"Make sure we can short-circuit around an unbound variable.","expr":"x || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n x^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x || true\n | ^"}]},{"name":"functions","tests":[{"original":{"name":"binop","expr":"1 + 1","value":{"int64Value":"2"}},"ast":"_+_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 1~int,\n 1~int\n)~int^add_int64","type":"int"},{"original":{"name":"unbound","expr":"f_unknown(17)","disableCheck":true,"evalError":{"errors":[{"message":"unbound function"}]}},"ast":"f_unknown(\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17)\n | .........^"},{"original":{"name":"unbound_is_runtime_error","expr":"f_unknown(17) || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n f_unknown(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17) || true\n | .........^"}]},{"name":"reserved_const","tests":[{"original":{"name":"false","expr":"false","typeEnv":[{"name":"false","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"false":{"value":{"boolValue":true}}},"value":{"boolValue":false}},"ast":"false^#*expr.Constant_BoolValue#","checkedAst":"false~bool","type":"bool"},{"original":{"name":"true","expr":"true","typeEnv":[{"name":"true","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"true":{"value":{"boolValue":false}}},"value":{"boolValue":true}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"null","expr":"null","typeEnv":[{"name":"null","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"null":{"value":{"boolValue":true}}},"value":{"nullValue":null}},"ast":"null^#*expr.Constant_NullValue#","checkedAst":"null~null","type":"null"}]}]},{"name":"bindings_ext","suites":[{"name":"bind","tests":[{"original":{"name":"boolean_literal","expr":"cel.bind(t, true, t)","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n t^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n t^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t~bool^t,\n // Result\n t~bool^t)~bool","type":"bool"},{"original":{"name":"string_concat","expr":"cel.bind(msg, \"hello\", msg + msg + msg)","value":{"stringValue":"hellohellohello"}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n msg^#*expr.Expr_IdentExpr#,\n \"hello\"^#*expr.Constant_StringValue#,\n _+_(\n _+_(\n msg^#*expr.Expr_IdentExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n msg,\n // Init\n \"hello\"~string,\n // LoopCondition\n false~bool,\n // LoopStep\n msg~string^msg,\n // Result\n _+_(\n _+_(\n msg~string^msg,\n msg~string^msg\n )~string^add_string,\n msg~string^msg\n )~string^add_string)~string","type":"string"},{"original":{"name":"bind_nested","expr":"cel.bind(t1, true, cel.bind(t2, true, t1 \u0026\u0026 t2))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n t1^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.bind(\n t2^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n _\u0026\u0026_(\n t1^#*expr.Expr_IdentExpr#,\n t2^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t1,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t1~bool^t1,\n // Result\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t2,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t2~bool^t2,\n // Result\n _\u0026\u0026_(\n t1~bool^t1,\n t2~bool^t2\n )~bool^logical_and)~bool)~bool","type":"bool"},{"original":{"name":"macro_exists","expr":"cel.bind(valid_elems, [1, 2, 3], [3, 4, 5].exists(e, e in valid_elems))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool)~bool","type":"bool"},{"original":{"name":"macro_not_exists","expr":"cel.bind(valid_elems, [1, 2, 3], ![4, 5].exists(e, e in valid_elems))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_not)~bool","type":"bool"}]}]},{"name":"block_ext","suites":[{"name":"basic","tests":[{"original":{"name":"int_add","expr":"cel.block([1, cel.index(0) + 1, cel.index(1) + 1, cel.index(2) + 1], cel.index(3))","value":{"int64Value":"4"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n 1^#*expr.Constant_Int64Value#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n 1~int,\n _+_(\n @index0~dyn^@index0,\n 1~int\n )~int^add_int64,\n _+_(\n @index1~dyn^@index1,\n 1~int\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(int),\n @index3~dyn^@index3\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_1","expr":"cel.block([[1, 2], size(cel.index(0)), cel.index(1) + cel.index(1), cel.index(2) + 1], cel.index(3))","value":{"int64Value":"5"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_2","expr":"cel.block([[1, 2], size(cel.index(0)), 2 + cel.index(1), cel.index(2) + cel.index(1), cel.index(3) + 1], cel.index(4))","value":{"int64Value":"7"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 2~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index3~dyn^@index3,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_3","expr":"cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), cel.index(1) + cel.index(1), cel.index(4) + cel.index(3), cel.index(5) + cel.index(3)], cel.index(6))","value":{"int64Value":"6"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index5~dyn^@index5,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_4","expr":"cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), [1, 2, 3], size(cel.index(4)), 5 + cel.index(1), cel.index(6) + cel.index(1), cel.index(7) + cel.index(3), cel.index(8) + cel.index(3), cel.index(9) + cel.index(5), cel.index(10) + cel.index(5)], cel.index(11))","value":{"int64Value":"17"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n size(\n @index4~dyn^@index4\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 5~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index6~dyn^@index6,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index7~dyn^@index7,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index8~dyn^@index8,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index9~dyn^@index9,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index10~dyn^@index10,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"timestamp","expr":"cel.block([timestamp(1000000000), int(cel.index(0)), timestamp(cel.index(1)), cel.index(2).getFullYear(), timestamp(50), int(cel.index(4)), timestamp(cel.index(5)), timestamp(200), int(cel.index(7)), timestamp(cel.index(8)), cel.index(9).getFullYear(), timestamp(75), int(cel.index(11)), timestamp(cel.index(12)), cel.index(13).getFullYear(), cel.index(3) + cel.index(14), cel.index(6).getFullYear(), cel.index(15) + cel.index(16), cel.index(17) + cel.index(3), cel.index(6).getSeconds(), cel.index(18) + cel.index(19), cel.index(20) + cel.index(10), cel.index(21) + cel.index(10), cel.index(13).getMinutes(), cel.index(22) + cel.index(23), cel.index(24) + cel.index(3)], cel.index(25))","value":{"int64Value":"13934"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 200^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 14^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 16^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 18^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 19^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 21^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp,\n int(\n @index0~dyn^@index0\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index1~dyn^@index1\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index2~dyn^@index2.getFullYear()~int^timestamp_to_year,\n timestamp(\n 50~int\n )~timestamp^int64_to_timestamp,\n int(\n @index4~dyn^@index4\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index5~dyn^@index5\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n timestamp(\n 200~int\n )~timestamp^int64_to_timestamp,\n int(\n @index7~dyn^@index7\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index8~dyn^@index8\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index9~dyn^@index9.getFullYear()~int^timestamp_to_year,\n timestamp(\n 75~int\n )~timestamp^int64_to_timestamp,\n int(\n @index11~dyn^@index11\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index12~dyn^@index12\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index13~dyn^@index13.getFullYear()~int^timestamp_to_year,\n _+_(\n @index3~dyn^@index3,\n @index14~dyn^@index14\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getFullYear()~int^timestamp_to_year,\n _+_(\n @index15~dyn^@index15,\n @index16~dyn^@index16\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index17~dyn^@index17,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getSeconds()~int^duration_to_seconds|timestamp_to_seconds,\n _+_(\n @index18~dyn^@index18,\n @index19~dyn^@index19\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index20~dyn^@index20,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index21~dyn^@index21,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index13~dyn^@index13.getMinutes()~int^duration_to_minutes|timestamp_to_minutes,\n _+_(\n @index22~dyn^@index22,\n @index23~dyn^@index23\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index24~dyn^@index24,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index25~dyn^@index25\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"map_index","expr":"cel.block([{\"a\": 2}, cel.index(0)[\"a\"], cel.index(1) * cel.index(1), cel.index(1) + cel.index(2)], cel.index(3))","value":{"int64Value":"6"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"a\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"a\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"a\"~string:2~int\n }~map(string, int),\n _[_](\n @index0~dyn^@index0,\n \"a\"~string\n )~dyn^index_map|optional_map_index_value,\n _*_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^multiply_double|multiply_int64|multiply_uint64,\n _+_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"nested_map_construction","expr":"cel.block([{\"b\": 1}, {\"e\": cel.index(0)}], {\"a\": cel.index(0), \"c\": cel.index(0), \"d\": cel.index(1), \"e\": cel.index(1)})","value":{"mapValue":{"entries":[{"key":{"stringValue":"a"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}},{"key":{"stringValue":"c"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}},{"key":{"stringValue":"d"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"e"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}}]}}},{"key":{"stringValue":"e"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"e"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}}]}}}]}}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"b\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"e\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n {\n \"a\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"c\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"d\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"e\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"b\"~string:1~int\n }~map(string, int),\n {\n \"e\"~string:@index0~dyn^@index0\n }~map(string, dyn)\n ]~list(map(string, dyn)),\n {\n \"a\"~string:@index0~dyn^@index0,\n \"c\"~string:@index0~dyn^@index0,\n \"d\"~string:@index1~dyn^@index1,\n \"e\"~string:@index1~dyn^@index1\n }~map(string, dyn)\n)~map(string, dyn)^cel_block_list","type":"map(string, dyn)"},{"original":{"name":"nested_list_construction","expr":"cel.block([[1, 2, 3, 4], [1, 2], [cel.index(1), cel.index(0)]], [1, cel.index(0), 2, cel.index(0), 5, cel.index(0), 7, cel.index(2), cel.index(1)])","value":{"listValue":{"values":[{"int64Value":"1"},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"int64Value":"2"},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"int64Value":"5"},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"int64Value":"7"},{"listValue":{"values":[{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"}]}},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}}]}},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"}]}}]}}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n [\n 1~int,\n 2~int\n ]~list(int),\n [\n @index1~dyn^@index1,\n @index0~dyn^@index0\n ]~list(dyn)\n ]~list(list(dyn)),\n [\n 1~int,\n @index0~dyn^@index0,\n 2~int,\n @index0~dyn^@index0,\n 5~int,\n @index0~dyn^@index0,\n 7~int,\n @index2~dyn^@index2,\n @index1~dyn^@index1\n ]~list(dyn)\n)~list(dyn)^cel_block_list","type":"list(dyn)"},{"original":{"name":"select","expr":"cel.block([msg.single_int64, cel.index(0) + cel.index(0)], cel.index(1))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"6"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index0~dyn^@index0,\n @index0~dyn^@index0\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index1~dyn^@index1\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"select_nested_1","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, cel.index(1).single_int32, cel.index(2) + cel.index(3), cel.index(4) + cel.index(2), msg.single_int64, cel.index(5) + cel.index(6), cel.index(1).oneof_type, cel.index(8).payload, cel.index(9).single_int64, cel.index(7) + cel.index(10)], cel.index(11))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"31"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int32~dyn,\n _+_(\n @index2~dyn^@index2,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index1~dyn^@index1.oneof_type~dyn,\n @index8~dyn^@index8.payload~dyn,\n @index9~dyn^@index9.single_int64~dyn,\n _+_(\n @index7~dyn^@index7,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"select_nested_2","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).oneof_type, cel.index(2).payload, cel.index(3).oneof_type, cel.index(4).payload, cel.index(5).oneof_type, cel.index(6).payload, cel.index(7).single_bool, true || cel.index(8), cel.index(4).child, cel.index(10).child, cel.index(11).payload, cel.index(12).single_bool], cel.index(9) || cel.index(13))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#,\n _||_(\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _||_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.oneof_type~dyn,\n @index2~dyn^@index2.payload~dyn,\n @index3~dyn^@index3.oneof_type~dyn,\n @index4~dyn^@index4.payload~dyn,\n @index5~dyn^@index5.oneof_type~dyn,\n @index6~dyn^@index6.payload~dyn,\n @index7~dyn^@index7.single_bool~dyn,\n _||_(\n true~bool,\n @index8~dyn^@index8\n )~bool^logical_or,\n @index4~dyn^@index4.child~dyn,\n @index10~dyn^@index10.child~dyn,\n @index11~dyn^@index11.payload~dyn,\n @index12~dyn^@index12.single_bool~dyn\n ]~list(dyn),\n _||_(\n @index9~dyn^@index9,\n @index13~dyn^@index13\n )~bool^logical_or\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"select_nested_message_map_index_1","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[1], cel.index(3) + cel.index(3), cel.index(4) + cel.index(3)], cel.index(5))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"15"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"select_nested_message_map_index_2","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[0], cel.index(2)[1], cel.index(3) + cel.index(4), cel.index(2)[2], cel.index(5) + cel.index(6)], cel.index(7))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"8"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 0~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _[_](\n @index2~dyn^@index2,\n 2~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index7~dyn^@index7\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"ternary","expr":"cel.block([msg.single_int64, cel.index(0) \u003e 0, cel.index(1) ? cel.index(0) : 0], cel.index(2))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"3"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _?_:_(\n @index1~dyn^@index1,\n @index0~dyn^@index0,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index2~dyn^@index2\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"nested_ternary","expr":"cel.block([msg.single_int64, msg.single_int32, cel.index(0) \u003e 0, cel.index(1) \u003e 0, cel.index(0) + cel.index(1), cel.index(3) ? cel.index(4) : 0, cel.index(2) ? cel.index(5) : 0], cel.index(6))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"8"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int32~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _\u003e_(\n @index1~dyn^@index1,\n 0~int\n )~bool^greater_int64,\n _+_(\n @index0~dyn^@index0,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _?_:_(\n @index3~dyn^@index3,\n @index4~dyn^@index4,\n 0~int\n )~dyn^conditional,\n _?_:_(\n @index2~dyn^@index2,\n @index5~dyn^@index5,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"multiple_macros_1","expr":"cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))","value":{"int64Value":"4"}},"error":"ERROR: multiple_macros_1:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_1:1:110: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .............................................................................................................^"},{"original":{"name":"multiple_macros_2","expr":"cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))","value":{"listValue":{"values":[{"boolValue":true},{"boolValue":true},{"boolValue":true},{"boolValue":true}]}}},"error":"ERROR: multiple_macros_2:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_2:1:106: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .........................................................................................................^"},{"original":{"name":"multiple_macros_3","expr":"cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))","value":{"boolValue":false}},"error":"ERROR: multiple_macros_3:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | .................................^\nERROR: multiple_macros_3:1:121: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ........................................................................................................................^\nERROR: multiple_macros_3:1:177: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ................................................................................................................................................................................^"},{"original":{"name":"nested_macros_1","expr":"cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))","value":{"listValue":{"values":[{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}}]}}},"error":"ERROR: nested_macros_1:1:52: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | ...................................................^\nERROR: nested_macros_1:1:88: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | .......................................................................................^"},{"original":{"name":"nested_macros_2","expr":"[1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))","value":{"listValue":{"values":[{"listValue":{"values":[{"int64Value":"1"}]}},{"listValue":{"values":[{"int64Value":"2"}]}}]}}},"error":"ERROR: nested_macros_2:1:23: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ......................^\nERROR: nested_macros_2:1:59: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ..........................................................^"},{"original":{"name":"adjacent_macros","expr":"cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))","value":{"boolValue":true}},"error":"ERROR: adjacent_macros:1:51: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ..................................................^\nERROR: adjacent_macros:1:87: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ......................................................................................^"},{"original":{"name":"macro_shadowed_variable_1","expr":"cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"5"}}},"value":{"boolValue":true}},"error":"ERROR: macro_shadowed_variable_1:1:90: argument must be a simple name\n | cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))\n | .........................................................................................^"},{"original":{"name":"macro_shadowed_variable_2","expr":"['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"5"}}},"value":{"listValue":{"values":[{"listValue":{"values":[{"listValue":{"values":[{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"}]}},{"listValue":{"values":[{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"}]}}]}},{"listValue":{"values":[{"listValue":{"values":[{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"}]}},{"listValue":{"values":[{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"}]}}]}}]}}},"error":"ERROR: macro_shadowed_variable_2:1:31: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | ..............................^\nERROR: macro_shadowed_variable_2:1:134: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | .....................................................................................................................................^"},{"original":{"name":"inclusion_list","expr":"cel.block([[1, 2, 3], 1 in cel.index(0), 2 in cel.index(0), cel.index(1) \u0026\u0026 cel.index(2), [3, cel.index(0)], 3 in cel.index(4), cel.index(5) \u0026\u0026 cel.index(1)], cel.index(3) \u0026\u0026 cel.index(6))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n @in(\n 1~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n @in(\n 2~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and,\n [\n 3~int,\n @index0~dyn^@index0\n ]~list(dyn),\n @in(\n 3~int,\n @index4~dyn^@index4\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index1~dyn^@index1\n )~bool^logical_and\n ]~list(dyn),\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index6~dyn^@index6\n )~bool^logical_and\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"inclusion_map","expr":"cel.block([{true: false}, {\"a\": 1, 2: cel.index(0), 3: cel.index(0)}], 2 in cel.index(1))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n true^#*expr.Constant_BoolValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n true~bool:false~bool\n }~map(bool, bool),\n {\n \"a\"~string:1~int,\n 2~int:@index0~dyn^@index0,\n 3~int:@index0~dyn^@index0\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn)),\n @in(\n 2~int,\n @index1~dyn^@index1\n )~bool^in_list|in_map\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"presence_test","expr":"cel.block([{\"a\": true}, has(cel.index(0).a), cel.index(0)[\"a\"]], cel.index(1) \u0026\u0026 cel.index(2))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"a\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"a\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"a\"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool,\n _[_](\n @index0~dyn^@index0,\n \"a\"~string\n )~dyn^index_map|optional_map_index_value\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"presence_test_2","expr":"cel.block([{\"a\": true}, has(cel.index(0).a)], cel.index(1) \u0026\u0026 cel.index(1))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"a\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"a\"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~bool^logical_and\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"presence_test_with_ternary","expr":"cel.block([msg.oneof_type, has(cel.index(0).payload), cel.index(0).payload, cel.index(2).single_int64, cel.index(1) ? cel.index(3) : 0], cel.index(4))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"10"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~test-only~~bool,\n @index0~dyn^@index0.payload~dyn,\n @index2~dyn^@index2.single_int64~dyn,\n _?_:_(\n @index1~dyn^@index1,\n @index3~dyn^@index3,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"presence_test_with_ternary_2","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(0).payload), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"10"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index0~dyn^@index0.payload~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"presence_test_with_ternary_3","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(1).single_int64), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"10"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"presence_test_with_ternary_nested","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_string_string, has(msg.oneof_type), has(cel.index(0).payload), cel.index(3) \u0026\u0026 cel.index(4), has(cel.index(1).single_int64), cel.index(5) \u0026\u0026 cel.index(6), has(cel.index(1).map_string_string), has(cel.index(2).key), cel.index(8) \u0026\u0026 cel.index(9), cel.index(2).key, cel.index(11) == \"A\", cel.index(10) ? cel.index(12) : false], cel.index(7) ? cel.index(13) : false)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.oneof_type~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key^#*expr.Expr_SelectExpr#,\n _==_(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"A\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_string_string~dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~test-only~~bool,\n @index0~dyn^@index0.payload~test-only~~bool,\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~bool^logical_and,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~bool^logical_and,\n @index1~dyn^@index1.map_string_string~test-only~~bool,\n @index2~dyn^@index2.key~test-only~~bool,\n _\u0026\u0026_(\n @index8~dyn^@index8,\n @index9~dyn^@index9\n )~bool^logical_and,\n @index2~dyn^@index2.key~dyn,\n _==_(\n @index11~dyn^@index11,\n \"A\"~string\n )~bool^equals,\n _?_:_(\n @index10~dyn^@index10,\n @index12~dyn^@index12,\n false~bool\n )~dyn^conditional\n ]~list(dyn),\n _?_:_(\n @index7~dyn^@index7,\n @index13~dyn^@index13,\n false~bool\n )~dyn^conditional\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"optional_list","expr":"cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))","typeEnv":[{"name":"opt_x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"opt_x":{"value":{"int64Value":"5"}}},"value":{"boolValue":true}},"error":"ERROR: optional_list:1:30: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | .............................^\nERROR: optional_list:1:45: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................^\nERROR: optional_list:1:77: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................................................^"},{"original":{"name":"optional_map","expr":"cel.block([optional.of(\"hello\"), {?\"hello\": cel.index(0)}, cel.index(1)[\"hello\"], cel.index(2) + cel.index(2)], cel.index(3) == \"hellohello\")","value":{"boolValue":true}},"error":"ERROR: optional_map:1:35: unsupported syntax '?'\n | cel.block([optional.of(\"hello\"), {?\"hello\": cel.index(0)}, cel.index(1)[\"hello\"], cel.index(2) + cel.index(2)], cel.index(3) == \"hellohello\")\n | ..................................^"},{"original":{"name":"optional_map_chained","expr":"cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))","value":{"stringValue":"test"}},"error":"ERROR: optional_map_chained:1:51: unsupported syntax '?'\n | cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | ..................................................^\nERROR: optional_map_chained:1:86: unsupported syntax '[?'\n | cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .....................................................................................^\nERROR: optional_map_chained:1:110: unsupported syntax '[?'\n | cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .............................................................................................................^"},{"original":{"name":"optional_message","expr":"cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))","container":"cel.expr.conformance.proto3","value":{"int64Value":"5"}},"error":"ERROR: optional_message:1:69: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | ....................................................................^\nERROR: optional_message:1:98: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | .................................................................................................^"},{"original":{"name":"call","expr":"cel.block([\"h\" + \"e\", cel.index(0) + \"l\", cel.index(1) + \"l\", cel.index(2) + \"o\", cel.index(3) + \" world\"], cel.index(4).matches(cel.index(3)))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n _+_(\n \"h\"^#*expr.Constant_StringValue#,\n \"e\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"l\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"l\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"o\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \" world\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.matches(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n _+_(\n \"h\"~string,\n \"e\"~string\n )~string^add_string,\n _+_(\n @index0~dyn^@index0,\n \"l\"~string\n )~string^add_string,\n _+_(\n @index1~dyn^@index1,\n \"l\"~string\n )~string^add_string,\n _+_(\n @index2~dyn^@index2,\n \"o\"~string\n )~string^add_string,\n _+_(\n @index3~dyn^@index3,\n \" world\"~string\n )~string^add_string\n ]~list(string),\n @index4~dyn^@index4.matches(\n @index3~dyn^@index3\n )~bool^matches_string\n)~bool^cel_block_list","type":"bool"}]}]},{"name":"comparisons","suites":[{"name":"eq_literal","tests":[{"original":{"name":"eq_int","expr":"1 == 1","value":{"boolValue":true}},"ast":"_==_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 1~int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int","expr":"-1 == 1","value":{"boolValue":false}},"ast":"_==_(\n -1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n -1~int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int_uint","expr":"dyn(1) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int_uint","expr":"dyn(2) == 1u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int_double","expr":"dyn(1) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int_double","expr":"dyn(2) == 1.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint","expr":"2u == 2u","value":{"boolValue":true}},"ast":"_==_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 2u~uint,\n 2u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint","expr":"1u == 2u","value":{"boolValue":false}},"ast":"_==_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 1u~uint,\n 2u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint_int","expr":"dyn(1u) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint_int","expr":"dyn(2u) == 1","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint_double","expr":"dyn(1u) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint_double","expr":"dyn(2u) == 1.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double","expr":"1.0 == 1.0e+0","value":{"boolValue":true}},"ast":"_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 1~double,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double","expr":"-1.0 == 1.0","value":{"boolValue":false}},"ast":"_==_(\n -1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n -1~double,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double_nan","expr":"0.0/0.0 == 0.0/0.0","value":{"boolValue":false}},"ast":"_==_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int_double_nan","expr":"dyn(1) == 0.0/0.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint_double_nan","expr":"dyn(1u) == 0.0/0.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_int","expr":"dyn(1.0) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double_int","expr":"dyn(2.0) == 1","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_uint","expr":"dyn(1.0) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double_uint","expr":"dyn(2.0) == 1u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string","expr":"'' == \"\"","value":{"boolValue":true}},"ast":"_==_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\"~string,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_string","expr":"'a' == 'b'","value":{"boolValue":false}},"ast":"_==_(\n \"a\"^#*expr.Constant_StringValue#,\n \"b\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"a\"~string,\n \"b\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_raw_string","expr":"'abc' == r'abc'","value":{"boolValue":true}},"ast":"_==_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"abc\"~string,\n \"abc\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_string_case","expr":"'abc' == 'ABC'","value":{"boolValue":false}},"ast":"_==_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"ABC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"abc\"~string,\n \"ABC\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_unicode","expr":"'ίσος' == 'ίσος'","value":{"boolValue":true}},"ast":"_==_(\n \"ίσος\"^#*expr.Constant_StringValue#,\n \"ίσος\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ίσος\"~string,\n \"ίσος\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_string_unicode_ascii","expr":"'a' == 'à'","value":{"boolValue":false}},"ast":"_==_(\n \"a\"^#*expr.Constant_StringValue#,\n \"à\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"a\"~string,\n \"à\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"no_string_normalization","description":"Should not normalize Unicode.","expr":"'Am\\u00E9lie' == 'Ame\\u0301lie'","value":{"boolValue":false}},"ast":"_==_(\n \"Amélie\"^#*expr.Constant_StringValue#,\n \"Amélie\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"Amélie\"~string,\n \"Amélie\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_null","expr":"null == null","value":{"boolValue":true}},"ast":"_==_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n null~null,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool","expr":"true == true","value":{"boolValue":true}},"ast":"_==_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n true~bool,\n true~bool\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_bool","expr":"false == true","value":{"boolValue":false}},"ast":"_==_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n false~bool,\n true~bool\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes","description":"Test bytes literal equality with encoding","expr":"b'ÿ' == b'\\303\\277'","value":{"boolValue":true}},"ast":"_==_(\n b\"ÿ\"^#*expr.Constant_BytesValue#,\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n b\"ÿ\"~bytes,\n b\"ÿ\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_bytes","expr":"b'abc' == b'abcd'","value":{"boolValue":false}},"ast":"_==_(\n b\"abc\"^#*expr.Constant_BytesValue#,\n b\"abcd\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n b\"abc\"~bytes,\n b\"abcd\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_empty","expr":"[] == []","value":{"boolValue":true}},"ast":"_==_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n []~list(dyn),\n []~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_null","expr":"[null] == [null]","value":{"boolValue":true}},"ast":"_==_(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n null~null\n ]~list(null),\n [\n null~null\n ]~list(null)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_null","expr":"['1', '2', null] == ['1', '2', '3']","value":{"boolValue":false}},"ast":"_==_(\n [\n \"1\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n \"1\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#,\n \"3\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"1\"~string,\n \"2\"~string,\n null~null\n ]~list(dyn),\n [\n \"1\"~string,\n \"2\"~string,\n \"3\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_numbers","expr":"[1, 2, 3] == [1, 2, 3]","value":{"boolValue":true}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_mixed_type_numbers","expr":"[1.0, 2.0, 3] == [1u, 2, 3u]","value":{"boolValue":true}},"ast":"_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~double,\n 2~double,\n 3~int\n ]~list(dyn),\n [\n 1u~uint,\n 2~int,\n 3u~uint\n ]~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_mixed_type_numbers","expr":"[1.0, 2.1] == [1u, 2]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2.1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~double,\n 2.1~double\n ]~list(double),\n [\n 1u~uint,\n 2~int\n ]~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_order","expr":"[1, 2, 3] == [1, 3, 2]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 3~int,\n 2~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_string_case","expr":"['case'] == ['cAse']","value":{"boolValue":false}},"ast":"_==_(\n [\n \"case\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n \"cAse\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"case\"~string\n ]~list(string),\n [\n \"cAse\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_length","expr":"['one'] == [2, 3]","disableCheck":true,"value":{"boolValue":false}},"ast":"_==_(\n [\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_==_' applied to '(list(string), list(int))'\n | ['one'] == [2, 3]\n | ........^"},{"original":{"name":"not_eq_list_false_vs_types","expr":"[1, 'dos', 3] == [1, 2, 4]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n \"dos\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n \"dos\"~string,\n 3~int\n ]~list(dyn),\n [\n 1~int,\n 2~int,\n 4~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_empty","expr":"{} == {}","value":{"boolValue":true}},"ast":"_==_(\n {}^#*expr.Expr_StructExpr#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {}~map(dyn, dyn),\n {}~map(dyn, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_null","expr":"{'k': null} == {'k': null}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:null~null\n }~map(string, null),\n {\n \"k\"~string:null~null\n }~map(string, null)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_null","expr":"{'k': 1, 'j': 2} == {'k': 1, 'j': null}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"j\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"j\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:1~int,\n \"j\"~string:2~int\n }~map(string, int),\n {\n \"k\"~string:1~int,\n \"j\"~string:null~null\n }~map(string, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_onekey","expr":"{'k':'v'} == {\"k\":\"v\"}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_double_value","expr":"{'k':1.0} == {'k':1e+0}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:1~double\n }~map(string, double),\n {\n \"k\"~string:1~double\n }~map(string, double)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_mixed_type_numbers","expr":"{1: 1.0, 2u: 3u} == {1u: 1, 2: 3.0}","value":{"boolValue":true}},"ast":"_==_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n 1~int:1~double,\n 2u~uint:3u~uint\n }~map(dyn, dyn),\n {\n 1u~uint:1~int,\n 2~int:3~double\n }~map(dyn, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_value","expr":"{'k':'v'} == {'k':'v1'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v1\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_extra_key","expr":"{'k':'v','k1':'v1'} == {'k':'v'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string,\n \"k1\"~string:\"v1\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_key_order","expr":"{'k1':'v1','k2':'v2'} == {'k2':'v2','k1':'v1'}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k2\"^#*expr.Constant_StringValue#:\"v2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k2\"^#*expr.Constant_StringValue#:\"v2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k1\"~string:\"v1\"~string,\n \"k2\"~string:\"v2\"~string\n }~map(string, string),\n {\n \"k2\"~string:\"v2\"~string,\n \"k1\"~string:\"v1\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_key_casing","expr":"{'key':'value'} == {'Key':'value'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"key\"^#*expr.Constant_StringValue#:\"value\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"Key\"^#*expr.Constant_StringValue#:\"value\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"key\"~string:\"value\"~string\n }~map(string, string),\n {\n \"Key\"~string:\"value\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_false_vs_types","expr":"{'k1': 1, 'k2': 'dos', 'k3': 3} == {'k1': 1, 'k2': 2, 'k3': 4}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"k2\"^#*expr.Constant_StringValue#:\"dos\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k3\"^#*expr.Constant_StringValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"k2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"k3\"^#*expr.Constant_StringValue#:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k1\"~string:1~int,\n \"k2\"~string:\"dos\"~string,\n \"k3\"~string:3~int\n }~map(string, dyn),\n {\n \"k1\"~string:1~int,\n \"k2\"~string:2~int,\n \"k3\"~string:4~int\n }~map(string, int)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_mixed_types","expr":"1.0 == 1","disableCheck":true,"value":{"boolValue":true}},"ast":"_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(double, int)'\n | 1.0 == 1\n | ....^"},{"original":{"name":"eq_list_elem_mixed_types","expr":"[1] == [1.0]","disableCheck":true,"value":{"boolValue":true}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(list(int), list(double))'\n | [1] == [1.0]\n | ....^"},{"original":{"name":"eq_map_value_mixed_types","expr":"{'k':'v', 1:1} == {'k':'v', 1:'v1'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string,\n 1~int:1~int\n }~map(dyn, dyn),\n {\n \"k\"~string:\"v\"~string,\n 1~int:\"v1\"~string\n }~map(dyn, string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_json_null","expr":"dyn(google.protobuf.Value{}) == null","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n google.protobuf.Value{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n google.protobuf.Value{}~dyn^google.protobuf.Value\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_bool_null","expr":"dyn(false) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n false~bool\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_bytes_null","expr":"dyn(b'') == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_double_null","expr":"dyn(2.1) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2.1~double\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_duration_null","expr":"dyn(duration('0s')) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n duration(\n \"0s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n duration(\n \"0s\"~string\n )~duration^string_to_duration\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_int_null","expr":"dyn(1) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_list_null","expr":"dyn([]) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_map_null","expr":"dyn({}) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n {}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n {}~map(dyn, dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_proto2_msg_null","expr":"dyn(TestAllTypes{}) == null","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_proto3_msg_null","expr":"dyn(TestAllTypes{}) == null","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_string_null","expr":"dyn('') == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n \"\"~string\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_timestamp_null","expr":"dyn(timestamp(0)) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n timestamp(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n timestamp(\n 0~int\n )~timestamp^int64_to_timestamp\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_elem_null","expr":"[1, 2, null] == [1, null, 3]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int,\n null~null\n ]~list(dyn),\n [\n 1~int,\n null~null,\n 3~int\n ]~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_value_null","expr":"{1:'hello', 2:'world'} == {1:'goodbye', 2:null}","value":{"boolValue":false}},"ast":"_==_(\n {\n 1^#*expr.Constant_Int64Value#:\"hello\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:\"world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n 1~int:\"hello\"~string,\n 2~int:\"world\"~string\n }~map(int, string),\n {\n 1~int:\"goodbye\"~string,\n 2~int:null~null\n }~map(int, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_int_uint","expr":"dyn(1) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_int_double","expr":"dyn(1) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_uint_int","expr":"dyn(1u) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_uint_double","expr":"dyn(1u) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_double_int","expr":"dyn(1.0) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_double_uint","expr":"dyn(1.0) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_int_uint","expr":"dyn(1) == 2u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_int_double","expr":"dyn(1) == 2.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_uint_int","expr":"dyn(1u) == 2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_uint_double","expr":"dyn(1u) == 120","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 120^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 120~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_double_int","expr":"dyn(1.0) == 2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_double_uint","expr":"dyn(1.0) == 2u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals","type":"bool"}]},{"name":"eq_wrapper","tests":[{"original":{"name":"eq_bool","expr":"google.protobuf.BoolValue{value: true} == true","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue,\n true~bool\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool_empty","expr":"google.protobuf.BoolValue{} == false","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n false~bool\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool_not_null","expr":"google.protobuf.BoolValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_bool_proto2_null","expr":"TestAllTypes{}.single_bool_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool_proto3_null","expr":"TestAllTypes{}.single_bool_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes","expr":"google.protobuf.BytesValue{value: b'set'} == b'set'","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BytesValue{\n value:b\"set\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n b\"set\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BytesValue{\n value:b\"set\"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue,\n b\"set\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes_empty","expr":"google.protobuf.BytesValue{} == b''","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n b\"\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes_not_null","expr":"google.protobuf.BytesValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_bytes_proto2_null","expr":"TestAllTypes{}.single_bytes_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes_proto3_null","expr":"TestAllTypes{}.single_bytes_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double","expr":"google.protobuf.DoubleValue{value: -1.175494e-40} == -1.175494e-40","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.175494e-40^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40~double\n }~wrapper(double)^google.protobuf.DoubleValue,\n -1.175494e-40~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_empty","expr":"google.protobuf.DoubleValue{} == 0.0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n 0~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_not_null","expr":"google.protobuf.DoubleValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_double_proto2_null","expr":"TestAllTypes{}.single_double_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_proto3_null","expr":"TestAllTypes{}.single_double_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float","expr":"google.protobuf.FloatValue{value: -1.5} == -1.5","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.FloatValue{\n value:-1.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:-1.5~double\n }~wrapper(double)^google.protobuf.FloatValue,\n -1.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float_empty","expr":"google.protobuf.FloatValue{} == 0.0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n 0~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float_not_null","expr":"google.protobuf.FloatValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_float_proto2_null","expr":"TestAllTypes{}.single_float_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float_proto3_null","expr":"TestAllTypes{}.single_float_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32","expr":"google.protobuf.Int32Value{value: 123} == 123","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int32Value{\n value:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:123~int\n }~wrapper(int)^google.protobuf.Int32Value,\n 123~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32_empty","expr":"google.protobuf.Int32Value{} == 0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32_not_null","expr":"google.protobuf.Int32Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_int32_proto2_null","expr":"TestAllTypes{}.single_int32_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32_proto3_null","expr":"TestAllTypes{}.single_int32_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64","expr":"google.protobuf.Int64Value{value: 2147483650} == 2147483650","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int64Value{\n value:2147483650^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2147483650^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int64Value{\n value:2147483650~int\n }~wrapper(int)^google.protobuf.Int64Value,\n 2147483650~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64_empty","expr":"google.protobuf.Int64Value{} == 0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64_not_null","expr":"google.protobuf.Int64Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_int64_proto2_null","expr":"TestAllTypes{}.single_int64_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64_proto3_null","expr":"TestAllTypes{}.single_int64_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string","expr":"google.protobuf.StringValue{value: 'set'} == 'set'","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.StringValue{\n value:\"set\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"set\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.StringValue{\n value:\"set\"~string\n }~wrapper(string)^google.protobuf.StringValue,\n \"set\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_empty","expr":"google.protobuf.StringValue{} == ''","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_not_null","expr":"google.protobuf.StringValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_string_proto2_null","expr":"TestAllTypes{}.single_string_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_proto3_null","expr":"TestAllTypes{}.single_string_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32","expr":"google.protobuf.UInt32Value{value: 42u} == 42u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt32Value{\n value:42u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:42u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n 42u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32_empty","expr":"google.protobuf.UInt32Value{} == 0u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n 0u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32_not_null","expr":"google.protobuf.UInt32Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_uint32_proto2_null","expr":"TestAllTypes{}.single_uint32_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32_proto3_null","expr":"TestAllTypes{}.single_uint32_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64","expr":"google.protobuf.UInt64Value{value: 4294967296u} == 4294967296u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt64Value{\n value:4294967296u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 4294967296u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt64Value{\n value:4294967296u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value,\n 4294967296u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64_empty","expr":"google.protobuf.UInt64Value{} == 0u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n 0u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64_not_null","expr":"google.protobuf.UInt64Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_uint64_proto2_null","expr":"TestAllTypes{}.single_uint64_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64_proto3_null","expr":"TestAllTypes{}.single_uint64_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto_nan_equal","description":"For proto equality, fields with NaN value are treated as not equal.","expr":"TestAllTypes{single_double: double('NaN')} == TestAllTypes{single_double: double('NaN')}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto_different_types","description":"At runtime, differently typed messages are treated as not equal.","expr":"dyn(TestAllTypes{}) == dyn(NestedTestAllTypes{})","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_not_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_bytewise_fallback_not_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_bytewise_fallback_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_not_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_bytewise_fallback_not_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_bytewise_fallback_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"ne_literal","tests":[{"original":{"name":"ne_int","expr":"24 != 42","value":{"boolValue":true}},"ast":"_!=_(\n 24^#*expr.Constant_Int64Value#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 24~int,\n 42~int\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int","expr":"1 != 1","value":{"boolValue":false}},"ast":"_!=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 1~int,\n 1~int\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_int_double","expr":"dyn(24) != 24.1","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 24.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 24.1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int_double","expr":"dyn(1) != 1.0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_int_uint","expr":"dyn(24) != 42u","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 42u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int_uint","expr":"dyn(1) != 1u","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_uint","expr":"1u != 2u","value":{"boolValue":true}},"ast":"_!=_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 1u~uint,\n 2u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_uint","expr":"99u != 99u","value":{"boolValue":false}},"ast":"_!=_(\n 99u^#*expr.Constant_Uint64Value#,\n 99u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 99u~uint,\n 99u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_uint_double","expr":"dyn(1u) != 2.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_uint_double","expr":"dyn(99u) != 99.0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 99u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 99u~uint\n )~dyn^to_dyn,\n 99~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double","expr":"9.0e+3 != 9001.0","value":{"boolValue":true}},"ast":"_!=_(\n 9000^#*expr.Constant_DoubleValue#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 9000~double,\n 9001~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double_nan","expr":"0.0/0.0 != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int_double_nan","expr":"dyn(1) != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_uint_double_nan","expr":"dyn(1u) != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double","expr":"1.0 != 1e+0","value":{"boolValue":false}},"ast":"_!=_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 1~double,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double_int","expr":"dyn(9000) != 9001.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 9000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 9000~int\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double_int","expr":"dyn(1) != 1e+0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double_uint","expr":"dyn(9000u) != 9001.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 9000u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 9000u~uint\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double_uint","expr":"dyn(1u) != 1e+0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double_nan","expr":"0.0/0.0 != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_string","expr":"'abc' != ''","value":{"boolValue":true}},"ast":"_!=_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"abc\"~string,\n \"\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_string","expr":"'abc' != 'abc'","value":{"boolValue":false}},"ast":"_!=_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"abc\"~string,\n \"abc\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_string_unicode","expr":"'résumé' != 'resume'","value":{"boolValue":true}},"ast":"_!=_(\n \"résumé\"^#*expr.Constant_StringValue#,\n \"resume\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"résumé\"~string,\n \"resume\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_string_unicode","expr":"'ίδιο' != 'ίδιο'","value":{"boolValue":false}},"ast":"_!=_(\n \"ίδιο\"^#*expr.Constant_StringValue#,\n \"ίδιο\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"ίδιο\"~string,\n \"ίδιο\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_bytes","expr":"b'\\x00\\xFF' != b'ÿ'","value":{"boolValue":true}},"ast":"_!=_(\n b\"\\x00\\xff\"^#*expr.Constant_BytesValue#,\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n b\"\\x00\\xff\"~bytes,\n b\"ÿ\"~bytes\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_bytes","expr":"b'\\303\\277' != b'ÿ'","value":{"boolValue":false}},"ast":"_!=_(\n b\"ÿ\"^#*expr.Constant_BytesValue#,\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n b\"ÿ\"~bytes,\n b\"ÿ\"~bytes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_bool","expr":"false != true","value":{"boolValue":true}},"ast":"_!=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n false~bool,\n true~bool\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_bool","expr":"true != true","value":{"boolValue":false}},"ast":"_!=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n true~bool,\n true~bool\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_null","description":"null can only be equal to null, or else it won't match","expr":"null != null","value":{"boolValue":false}},"ast":"_!=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n null~null,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_list_empty","expr":"[] != [1]","value":{"boolValue":true}},"ast":"_!=_(\n []^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n []~list(int),\n [\n 1~int\n ]~list(int)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_list_empty","expr":"[] != []","value":{"boolValue":false}},"ast":"_!=_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n []~list(dyn),\n []~list(dyn)\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_list_bool","expr":"[true, false, true] != [true, true, false]","value":{"boolValue":true}},"ast":"_!=_(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n [\n true~bool,\n false~bool,\n true~bool\n ]~list(bool),\n [\n true~bool,\n true~bool,\n false~bool\n ]~list(bool)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_list_bool","expr":"[false, true] != [false, true]","value":{"boolValue":false}},"ast":"_!=_(\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n [\n false~bool,\n true~bool\n ]~list(bool),\n [\n false~bool,\n true~bool\n ]~list(bool)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_list_of_list","expr":"[[]] != [[]]","value":{"boolValue":false}},"ast":"_!=_(\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n [\n []~list(dyn)\n ]~list(list(dyn)),\n [\n []~list(dyn)\n ]~list(list(dyn))\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_map_by_value","expr":"{'k':'v'} != {'k':'v1'}","value":{"boolValue":true}},"ast":"_!=_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"k\"~string:\"v\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v1\"~string\n }~map(string, string)\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_map_by_key","expr":"{'k':true} != {'k1':true}","value":{"boolValue":true}},"ast":"_!=_(\n {\n \"k\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k1\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"k\"~string:true~bool\n }~map(string, bool),\n {\n \"k1\"~string:true~bool\n }~map(string, bool)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_map_int_to_float","expr":"{1:1.0} != {1:1.0}","value":{"boolValue":false}},"ast":"_!=_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n 1~int:1~double\n }~map(int, double),\n {\n 1~int:1~double\n }~map(int, double)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_map_key_order","expr":"{'a':'b','c':'d'} != {'c':'d','a':'b'}","value":{"boolValue":false}},"ast":"_!=_(\n {\n \"a\"^#*expr.Constant_StringValue#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"c\"^#*expr.Constant_StringValue#:\"d\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"c\"^#*expr.Constant_StringValue#:\"d\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"a\"^#*expr.Constant_StringValue#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"a\"~string:\"b\"~string,\n \"c\"~string:\"d\"~string\n }~map(string, string),\n {\n \"c\"~string:\"d\"~string,\n \"a\"~string:\"b\"~string\n }~map(string, string)\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_mixed_types","expr":"2u != 2","disableCheck":true,"value":{"boolValue":false}},"ast":"_!=_(\n 2u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:4: found no matching overload for '_!=_' applied to '(uint, int)'\n | 2u != 2\n | ...^"},{"original":{"name":"ne_proto2","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto2_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto_nan_not_equal","description":"For proto equality, NaN field values are not considered equal.","expr":"TestAllTypes{single_double: double('NaN')} != TestAllTypes{single_double: double('NaN')}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto_different_types","description":"At runtime, comparing differently typed messages is false.","expr":"dyn(TestAllTypes{}) != dyn(NestedTestAllTypes{})","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto2_any_unpack","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto2_any_unpack_bytewise_fallback","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3_any_unpack","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3_any_unpack_bytewise_fallback","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"}]},{"name":"lt_literal","tests":[{"original":{"name":"lt_int","expr":"-1 \u003c 0","value":{"boolValue":true}},"ast":"_\u003c_(\n -1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n -1~int,\n 0~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_int","expr":"0 \u003c 0","value":{"boolValue":false}},"ast":"_\u003c_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 0~int,\n 0~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"lt_uint","expr":"0u \u003c 1u","value":{"boolValue":true}},"ast":"_\u003c_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 0u~uint,\n 1u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_uint","expr":"2u \u003c 2u","value":{"boolValue":false}},"ast":"_\u003c_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 2u~uint,\n 2u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_double","expr":"1.0 \u003c 1.0000001","value":{"boolValue":true}},"ast":"_\u003c_(\n 1^#*expr.Constant_DoubleValue#,\n 1.0000001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 1~double,\n 1.0000001~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_double","description":"Following IEEE 754, negative zero compares equal to zero","expr":"-0.0 \u003c 0.0","value":{"boolValue":false}},"ast":"_\u003c_(\n -0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n -0~double,\n 0~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_string","expr":"'a' \u003c 'b'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"a\"^#*expr.Constant_StringValue#,\n \"b\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"a\"~string,\n \"b\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_empty_to_nonempty","expr":"'' \u003c 'a'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"\"~string,\n \"a\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_case","expr":"'Abc' \u003c 'aBC'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"Abc\"^#*expr.Constant_StringValue#,\n \"aBC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"Abc\"~string,\n \"aBC\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_length","expr":"'abc' \u003c 'abcd'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abcd\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"abc\"~string,\n \"abcd\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_diacritical_mark_sensitive","description":"Verifies that the we're not using a string comparison function that strips diacritical marks (á)","expr":"'a' \u003c '\\u00E1'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"a\"^#*expr.Constant_StringValue#,\n \"á\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"a\"~string,\n \"á\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"not_lt_string_empty","expr":"'' \u003c ''","value":{"boolValue":false}},"ast":"_\u003c_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"\"~string,\n \"\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"not_lt_string_same","expr":"'abc' \u003c 'abc'","value":{"boolValue":false}},"ast":"_\u003c_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"abc\"~string,\n \"abc\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"not_lt_string_case_length","expr":"'a' \u003c 'AB'","value":{"boolValue":false}},"ast":"_\u003c_(\n \"a\"^#*expr.Constant_StringValue#,\n \"AB\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"a\"~string,\n \"AB\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"unicode_order_lexical","description":"Compare the actual code points of the string, instead of decomposing ế into 'e' plus accent modifiers.","expr":"'f' \u003c '\\u1EBF'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"f\"^#*expr.Constant_StringValue#,\n \"ế\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"f\"~string,\n \"ế\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_bytes","expr":"b'a' \u003c b'b'","value":{"boolValue":true}},"ast":"_\u003c_(\n b\"a\"^#*expr.Constant_BytesValue#,\n b\"b\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n b\"a\"~bytes,\n b\"b\"~bytes\n)~bool^less_bytes","type":"bool"},{"original":{"name":"not_lt_bytes_same","expr":"b'abc' \u003c b'abc'","value":{"boolValue":false}},"ast":"_\u003c_(\n b\"abc\"^#*expr.Constant_BytesValue#,\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n b\"abc\"~bytes,\n b\"abc\"~bytes\n)~bool^less_bytes","type":"bool"},{"original":{"name":"not_lt_bytes_width","expr":"b'á' \u003c b'b'","value":{"boolValue":false}},"ast":"_\u003c_(\n b\"á\"^#*expr.Constant_BytesValue#,\n b\"b\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n b\"á\"~bytes,\n b\"b\"~bytes\n)~bool^less_bytes","type":"bool"},{"original":{"name":"lt_bool_false_first","expr":"false \u003c true","value":{"boolValue":true}},"ast":"_\u003c_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n false~bool,\n true~bool\n)~bool^less_bool","type":"bool"},{"original":{"name":"not_lt_bool_same","expr":"true \u003c true","value":{"boolValue":false}},"ast":"_\u003c_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n true~bool,\n true~bool\n)~bool^less_bool","type":"bool"},{"original":{"name":"not_lt_bool_true_first","expr":"true \u003c false","value":{"boolValue":false}},"ast":"_\u003c_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n true~bool,\n false~bool\n)~bool^less_bool","type":"bool"},{"original":{"name":"lt_list_unsupported","expr":"[0] \u003c [1]","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c_' applied to '(list(int), list(int))'\n | [0] \u003c [1]\n | ....^"},{"original":{"name":"lt_map_unsupported","expr":"{0:'a'} \u003c {1:'b'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c {1:'b'}\n | ........^"},{"original":{"name":"lt_null_unsupported","description":"Ensure _\u003c_ doesn't have a binding for null","expr":"null \u003c null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n null~null,\n null~null\n)~bool^less_duration|less_timestamp","type":"bool"},{"original":{"name":"lt_mixed_types_error","expr":"'foo' \u003c 1024","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c_' applied to '(string, int)'\n | 'foo' \u003c 1024\n | ......^"},{"original":{"name":"lt_dyn_int_uint","expr":"dyn(1) \u003c 2u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_dyn_int_double","expr":"dyn(1) \u003c 2.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_uint_int","expr":"dyn(1u) \u003c 2","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"lt_dyn_uint_double","expr":"dyn(1u) \u003c 2.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_double_int","expr":"dyn(1.0) \u003c 2","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"lt_dyn_double_uint","expr":"dyn(1.0) \u003c 2u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_int_uint","expr":"dyn(1) \u003c 1u","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_int_double","expr":"dyn(1) \u003c 1.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_uint_int","expr":"dyn(1u) \u003c 1","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_uint_double","expr":"dyn(1u) \u003c 1.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_double_int","expr":"dyn(1.0) \u003c 1","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_double_uint","expr":"dyn(1.0) \u003c 1u","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_dyn_int_big_uint","expr":"dyn(1) \u003c 9223372036854775808u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_dyn_small_int_uint","expr":"dyn(-1) \u003c 0u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_int_big_lossy_double","expr":"dyn(9223372036854775807) \u003c 9223372036854775808.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_int_big_lossy_double","expr":"dyn(9223372036854775807) \u003c 9223372036854777857.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_int_small_double","expr":"dyn(9223372036854775807) \u003c -9223372036854777857.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_int_small_lossy_double","expr":"dyn(-9223372036854775808) \u003c -9223372036854775809.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_uint_small_int","expr":"dyn(1u) \u003c -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003c 1","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_uint_small_double","expr":"dyn(18446744073709551615u) \u003c -1.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003c 18446744073709590000.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003c 18446744073709551615u","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003c 9223372036854775807","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003c -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64","type":"bool"}]},{"name":"gt_literal","tests":[{"original":{"name":"gt_int","expr":"42 \u003e -42","value":{"boolValue":true}},"ast":"_\u003e_(\n 42^#*expr.Constant_Int64Value#,\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 42~int,\n -42~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_int","expr":"0 \u003e 0","value":{"boolValue":false}},"ast":"_\u003e_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 0~int,\n 0~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_uint","expr":"48u \u003e 46u","value":{"boolValue":true}},"ast":"_\u003e_(\n 48u^#*expr.Constant_Uint64Value#,\n 46u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 48u~uint,\n 46u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_uint","expr":"0u \u003e 999u","value":{"boolValue":false}},"ast":"_\u003e_(\n 0u^#*expr.Constant_Uint64Value#,\n 999u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 0u~uint,\n 999u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"gt_double","expr":"1e+1 \u003e 1e+0","value":{"boolValue":true}},"ast":"_\u003e_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 10~double,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_double","expr":".99 \u003e 9.9e-1","value":{"boolValue":false}},"ast":"_\u003e_(\n 0.99^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 0.99~double,\n 0.99~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_string_case","expr":"'abc' \u003e 'aBc'","value":{"boolValue":true}},"ast":"_\u003e_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"aBc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"abc\"~string,\n \"aBc\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"gt_string_to_empty","expr":"'A' \u003e ''","value":{"boolValue":true}},"ast":"_\u003e_(\n \"A\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"A\"~string,\n \"\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"not_gt_string_empty_to_empty","expr":"'' \u003e ''","value":{"boolValue":false}},"ast":"_\u003e_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"\"~string,\n \"\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"gt_string_unicode","expr":"'α' \u003e 'omega'","value":{"boolValue":true}},"ast":"_\u003e_(\n \"α\"^#*expr.Constant_StringValue#,\n \"omega\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"α\"~string,\n \"omega\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"gt_bytes_one","expr":"b'\u0001' \u003e b'\u0000'","value":{"boolValue":true}},"ast":"_\u003e_(\n b\"\\x01\"^#*expr.Constant_BytesValue#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n b\"\\x01\"~bytes,\n b\"\\x00\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"gt_bytes_one_to_empty","expr":"b'\u0000' \u003e b''","value":{"boolValue":true}},"ast":"_\u003e_(\n b\"\\x00\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n b\"\\x00\"~bytes,\n b\"\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"not_gt_bytes_sorting","expr":"b'\u0000\u0001' \u003e b'\u0001'","value":{"boolValue":false}},"ast":"_\u003e_(\n b\"\\x00\\x01\"^#*expr.Constant_BytesValue#,\n b\"\\x01\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n b\"\\x00\\x01\"~bytes,\n b\"\\x01\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"gt_bool_true_false","expr":"true \u003e false","value":{"boolValue":true}},"ast":"_\u003e_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n true~bool,\n false~bool\n)~bool^greater_bool","type":"bool"},{"original":{"name":"not_gt_bool_false_true","expr":"false \u003e true","value":{"boolValue":false}},"ast":"_\u003e_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n false~bool,\n true~bool\n)~bool^greater_bool","type":"bool"},{"original":{"name":"not_gt_bool_same","expr":"true \u003e true","value":{"boolValue":false}},"ast":"_\u003e_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n true~bool,\n true~bool\n)~bool^greater_bool","type":"bool"},{"original":{"name":"gt_null_unsupported","expr":"null \u003e null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n null~null,\n null~null\n)~bool^greater_duration|greater_timestamp","type":"bool"},{"original":{"name":"gt_list_unsupported","expr":"[1] \u003e [0]","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003e_' applied to '(list(int), list(int))'\n | [1] \u003e [0]\n | ....^"},{"original":{"name":"gt_map_unsupported","expr":"{1:'b'} \u003e {0:'a'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e {0:'a'}\n | ........^"},{"original":{"name":"gt_mixed_types_error","expr":"'foo' \u003e 1024","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e_' applied to '(string, int)'\n | 'foo' \u003e 1024\n | ......^"},{"original":{"name":"gt_dyn_int_uint","expr":"dyn(2) \u003e 1u","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"gt_dyn_int_double","expr":"dyn(2) \u003e 1.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_uint_int","expr":"dyn(2u) \u003e 1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_uint_double","expr":"dyn(2u) \u003e 1.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_double_int","expr":"dyn(2.0) \u003e 1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_double_uint","expr":"dyn(2.0) \u003e 1u","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_uint","expr":"dyn(1) \u003e 1u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_double","expr":"dyn(1) \u003e 1.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_uint_int","expr":"dyn(1u) \u003e 1","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_dyn_uint_double","expr":"dyn(1u) \u003e 1.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_double_int","expr":"dyn(1.0) \u003e 1","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_dyn_double_uint","expr":"dyn(1.0) \u003e 1u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_big_uint","expr":"dyn(1) \u003e 9223372036854775808u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_small_int_uint","expr":"dyn(-1) \u003e 0u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_big_double","expr":"dyn(9223372036854775807) \u003e 9223372036854775808.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_int_small_lossy_double","description":"The conversion of the int to double is lossy and the numbers end up being equal","expr":"dyn(-9223372036854775808) \u003e -9223372036854775809.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_int_small_lossy_double_greater","expr":"dyn(-9223372036854775808) \u003e -9223372036854777857.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_uint_small_int","expr":"dyn(1u) \u003e -1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003e 1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_uint_small_double","expr":"dyn(9223372036854775807u) \u003e -1.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003e 18446744073709590000.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003e 18446744073709551615u","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003e 9223372036854775807","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003e -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_int64","type":"bool"}]},{"name":"lte_literal","tests":[{"original":{"name":"lte_int_lt","expr":"0 \u003c= 1","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0~int,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_int_eq","expr":"1 \u003c= 1","value":{"boolValue":true}},"ast":"_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1~int,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_int_gt","expr":"1 \u003c= -1","value":{"boolValue":false}},"ast":"_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1~int,\n -1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_uint_lt","expr":"0u \u003c= 1u","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0u~uint,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_uint_eq","expr":"1u \u003c= 1u","value":{"boolValue":true}},"ast":"_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1u~uint,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"not_lte_uint_gt","expr":"1u \u003c= 0u","value":{"boolValue":false}},"ast":"_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1u~uint,\n 0u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_double_lt","expr":"0.0 \u003c= 0.1e-31","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 1e-32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0~double,\n 1e-32~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_double_eq","expr":"0.0 \u003c= 0e-1","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0~double,\n 0~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_double_gt","expr":"1.0 \u003c= 0.99","value":{"boolValue":false}},"ast":"_\u003c=_(\n 1^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1~double,\n 0.99~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_string_empty","expr":"'' \u003c= ''","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"\"~string,\n \"\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_from_empty","expr":"'' \u003c= 'a'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"\"~string,\n \"a\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"not_lte_string_to_empty","expr":"'a' \u003c= ''","value":{"boolValue":false}},"ast":"_\u003c=_(\n \"a\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"a\"~string,\n \"\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_lexicographical","expr":"'aBc' \u003c= 'abc'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"aBc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"aBc\"~string,\n \"abc\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_unicode_eq","expr":"'α' \u003c= 'α'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"α\"^#*expr.Constant_StringValue#,\n \"α\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"α\"~string,\n \"α\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_unicode_lt","expr":"'a' \u003c= 'α'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"a\"^#*expr.Constant_StringValue#,\n \"α\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"a\"~string,\n \"α\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"not_lte_string_unicode","expr":"'α' \u003c= 'a'","value":{"boolValue":false}},"ast":"_\u003c=_(\n \"α\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"α\"~string,\n \"a\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_bytes_empty","expr":"b'' \u003c= b'\u0000'","value":{"boolValue":true}},"ast":"_\u003c=_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n b\"\"~bytes,\n b\"\\x00\"~bytes\n)~bool^less_equals_bytes","type":"bool"},{"original":{"name":"not_lte_bytes_length","expr":"b'\u0001\u0000' \u003c= b'\u0001'","value":{"boolValue":false}},"ast":"_\u003c=_(\n b\"\\x01\\x00\"^#*expr.Constant_BytesValue#,\n b\"\\x01\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n b\"\\x01\\x00\"~bytes,\n b\"\\x01\"~bytes\n)~bool^less_equals_bytes","type":"bool"},{"original":{"name":"lte_bool_false_true","expr":"false \u003c= true","value":{"boolValue":true}},"ast":"_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n false~bool,\n true~bool\n)~bool^less_equals_bool","type":"bool"},{"original":{"name":"lte_bool_false_false","expr":"false \u003c= false","value":{"boolValue":true}},"ast":"_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n false~bool,\n false~bool\n)~bool^less_equals_bool","type":"bool"},{"original":{"name":"lte_bool_true_false","expr":"true \u003c= false","value":{"boolValue":false}},"ast":"_\u003c=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n true~bool,\n false~bool\n)~bool^less_equals_bool","type":"bool"},{"original":{"name":"lte_null_unsupported","expr":"null \u003c= null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n null~null,\n null~null\n)~bool^less_equals_duration|less_equals_timestamp","type":"bool"},{"original":{"name":"lte_list_unsupported","expr":"[0] \u003c= [0]","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c=_' applied to '(list(int), list(int))'\n | [0] \u003c= [0]\n | ....^"},{"original":{"name":"lte_map_unsupported","expr":"{0:'a'} \u003c= {1:'b'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c=_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c= {1:'b'}\n | ........^"},{"original":{"name":"lte_mixed_types_error","expr":"'foo' \u003c= 1024","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c=_' applied to '(string, int)'\n | 'foo' \u003c= 1024\n | ......^"},{"original":{"name":"lte_dyn_int_uint","expr":"dyn(1) \u003c= 2u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_int_double","expr":"dyn(1) \u003c= 2.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_uint_int","expr":"dyn(1u) \u003c= 2","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_dyn_uint_double","expr":"dyn(1u) \u003c= 2.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_double_int","expr":"dyn(1.0) \u003c= 2","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_dyn_double_uint","expr":"dyn(1.0) \u003c= 2u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"not_lte_dyn_int_uint","expr":"dyn(2) \u003c= 1u","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"not_lte_dyn_int_double","expr":"dyn(2) \u003c= 1.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_uint_int","expr":"dyn(2u) \u003c= 1","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_uint_double","expr":"dyn(2u) \u003c= 1.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_double_int","expr":"dyn(2.0) \u003c= 1","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_double_uint","expr":"dyn(2.0) \u003c= 1u","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_int_big_uint","expr":"dyn(1) \u003c= 9223372036854775808u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_small_int_uint","expr":"dyn(-1) \u003c= 0u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_int_big_double","expr":"dyn(9223372036854775807) \u003c= 9223372036854775808.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_int_small_lossy_double","description":"The conversion of the int to double is lossy and the numbers end up being equal","expr":"dyn(-9223372036854775808) \u003c= -9223372036854775809.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_int_small_lossy_double_less","expr":"dyn(-9223372036854775808) \u003c= -9223372036854777857.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_uint_small_int","expr":"dyn(1u) \u003c= -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003c= 1","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_uint_small_double","expr":"dyn(18446744073709551615u) \u003c= -1.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003c= 18446744073709590000.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003c= 18446744073709551615u","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003c= 9223372036854775807","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003c= -9223372036854775808","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64","type":"bool"}]},{"name":"gte_literal","tests":[{"original":{"name":"gte_int_gt","expr":"0 \u003e= -1","value":{"boolValue":true}},"ast":"_\u003e=_(\n 0^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 0~int,\n -1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_int_eq","expr":"999 \u003e= 999","value":{"boolValue":true}},"ast":"_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 999^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 999~int,\n 999~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"not_gte_int_lt","expr":"999 \u003e= 1000","value":{"boolValue":false}},"ast":"_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 1000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 999~int,\n 1000~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_uint_gt","expr":"1u \u003e= 0u","value":{"boolValue":true}},"ast":"_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 1u~uint,\n 0u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_uint_eq","expr":"0u \u003e= 0u","value":{"boolValue":true}},"ast":"_\u003e=_(\n 0u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 0u~uint,\n 0u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_uint_lt","expr":"1u \u003e= 10u","value":{"boolValue":false}},"ast":"_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 1u~uint,\n 10u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_double_gt","expr":"1e+1 \u003e= 1e+0","value":{"boolValue":true}},"ast":"_\u003e=_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 10~double,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_double_eq","expr":"9.80665 \u003e= 9.80665e+0","value":{"boolValue":true}},"ast":"_\u003e=_(\n 9.80665^#*expr.Constant_DoubleValue#,\n 9.80665^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 9.80665~double,\n 9.80665~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_double_lt","expr":"0.9999 \u003e= 1.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n 0.9999^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 0.9999~double,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_string_empty","expr":"'' \u003e= ''","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"\"~string,\n \"\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_to_empty","expr":"'a' \u003e= ''","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"a\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"a\"~string,\n \"\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_empty_to_nonempty","expr":"'' \u003e= 'a'","value":{"boolValue":false}},"ast":"_\u003e=_(\n \"\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"\"~string,\n \"a\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_length","expr":"'abcd' \u003e= 'abc'","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"abcd\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"abcd\"~string,\n \"abc\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"not_gte_string_lexicographical","expr":"'abc' \u003e= 'abd'","value":{"boolValue":false}},"ast":"_\u003e=_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abd\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"abc\"~string,\n \"abd\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_unicode_eq","expr":"'τ' \u003e= 'τ'","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"τ\"^#*expr.Constant_StringValue#,\n \"τ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"τ\"~string,\n \"τ\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_unicode_gt","expr":"'τ' \u003e= 't'","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"τ\"^#*expr.Constant_StringValue#,\n \"t\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"τ\"~string,\n \"t\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"not_get_string_unicode","expr":"'t' \u003e= 'τ'","value":{"boolValue":false}},"ast":"_\u003e=_(\n \"t\"^#*expr.Constant_StringValue#,\n \"τ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"t\"~string,\n \"τ\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_bytes_to_empty","expr":"b'\u0000' \u003e= b''","value":{"boolValue":true}},"ast":"_\u003e=_(\n b\"\\x00\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n b\"\\x00\"~bytes,\n b\"\"~bytes\n)~bool^greater_equals_bytes","type":"bool"},{"original":{"name":"not_gte_bytes_empty_to_nonempty","expr":"b'' \u003e= b'\u0000'","value":{"boolValue":false}},"ast":"_\u003e=_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n b\"\"~bytes,\n b\"\\x00\"~bytes\n)~bool^greater_equals_bytes","type":"bool"},{"original":{"name":"gte_bytes_samelength","expr":"b'\u0000\u0001' \u003e= b'\u0001\u0000'","value":{"boolValue":false}},"ast":"_\u003e=_(\n b\"\\x00\\x01\"^#*expr.Constant_BytesValue#,\n b\"\\x01\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n b\"\\x00\\x01\"~bytes,\n b\"\\x01\\x00\"~bytes\n)~bool^greater_equals_bytes","type":"bool"},{"original":{"name":"gte_bool_gt","expr":"true \u003e= false","value":{"boolValue":true}},"ast":"_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n true~bool,\n false~bool\n)~bool^greater_equals_bool","type":"bool"},{"original":{"name":"gte_bool_eq","expr":"true \u003e= true","value":{"boolValue":true}},"ast":"_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n true~bool,\n true~bool\n)~bool^greater_equals_bool","type":"bool"},{"original":{"name":"not_gte_bool_lt","expr":"false \u003e= true","value":{"boolValue":false}},"ast":"_\u003e=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n false~bool,\n true~bool\n)~bool^greater_equals_bool","type":"bool"},{"original":{"name":"gte_null_unsupported","expr":"null \u003e= null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n null~null,\n null~null\n)~bool^greater_equals_duration|greater_equals_timestamp","type":"bool"},{"original":{"name":"gte_list_unsupported","expr":"['y'] \u003e= ['x']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n [\n \"y\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n \"x\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(list(string), list(string))'\n | ['y'] \u003e= ['x']\n | ......^"},{"original":{"name":"gte_map_unsupported","expr":"{1:'b'} \u003e= {0:'a'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e=_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e= {0:'a'}\n | ........^"},{"original":{"name":"gte_mixed_types_error","expr":"'foo' \u003e= 1.0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(string, double)'\n | 'foo' \u003e= 1.0\n | ......^"},{"original":{"name":"gte_dyn_int_uint","expr":"dyn(2) \u003e= 1u","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_dyn_int_double","expr":"dyn(2) \u003e= 1.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_uint_int","expr":"dyn(2u) \u003e= 1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_uint_double","expr":"dyn(2u) \u003e= 1.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_double_int","expr":"dyn(2.0) \u003e= 1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_double_uint","expr":"dyn(2.0) \u003e= 1u","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_int_uint","expr":"dyn(0) \u003e= 1u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_int_double","expr":"dyn(0) \u003e= 1.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_uint_int","expr":"dyn(0u) \u003e= 1","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"not_gte_dyn_uint_double","expr":"dyn(0u) \u003e= 1.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_double_int","expr":"dyn(0.0) \u003e= 1","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"not_gte_dyn_double_uint","expr":"dyn(0.0) \u003e= 1u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_int_big_uint","expr":"dyn(1) \u003e= 9223372036854775808u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_small_int_uint","expr":"dyn(-1) \u003e= 0u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_dyn_int_big_lossy_double","expr":"dyn(9223372036854775807) \u003e= 9223372036854775808.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_int_big_double","expr":"dyn(9223372036854775807) \u003e= 9223372036854777857.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_int_small_lossy_double_equal","description":"The conversion of the int to double is lossy and the numbers end up being equal","expr":"dyn(-9223372036854775808) \u003e= -9223372036854775809.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_int_small_lossy_double_greater","expr":"dyn(-9223372036854775808) \u003e= -9223372036854777857.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_uint_small_int","expr":"dyn(1u) \u003e= -1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003e= 1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_uint_small_double","expr":"dyn(9223372036854775807u) \u003e= -1.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003e= 18446744073709553665.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.8446744073709556e+19~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003e= 18446744073709551615u","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003e= 9223372036854775807","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003e= -9223372036854775808","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_equals_int64","type":"bool"}]},{"name":"in_list_literal","tests":[{"original":{"name":"elem_not_in_empty_list","expr":"'empty' in []","value":{"boolValue":false}},"ast":"@in(\n \"empty\"^#*expr.Constant_StringValue#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"empty\"~string,\n []~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_in_list","expr":"'elem' in ['elem', 'elemA', 'elemB']","value":{"boolValue":true}},"ast":"@in(\n \"elem\"^#*expr.Constant_StringValue#,\n [\n \"elem\"^#*expr.Constant_StringValue#,\n \"elemA\"^#*expr.Constant_StringValue#,\n \"elemB\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"elem\"~string,\n [\n \"elem\"~string,\n \"elemA\"~string,\n \"elemB\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_not_in_list","expr":"'not' in ['elem1', 'elem2', 'elem3']","value":{"boolValue":false}},"ast":"@in(\n \"not\"^#*expr.Constant_StringValue#,\n [\n \"elem1\"^#*expr.Constant_StringValue#,\n \"elem2\"^#*expr.Constant_StringValue#,\n \"elem3\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"not\"~string,\n [\n \"elem1\"~string,\n \"elem2\"~string,\n \"elem3\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_in_mixed_type_list","description":"Set membership tests should succeed if the 'elem' exists in a mixed element type list.","expr":"'elem' in [1, 'elem', 2]","value":{"boolValue":true}},"ast":"@in(\n \"elem\"^#*expr.Constant_StringValue#,\n [\n 1^#*expr.Constant_Int64Value#,\n \"elem\"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"elem\"~string,\n [\n 1~int,\n \"elem\"~string,\n 2~int\n ]~list(dyn)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_in_mixed_type_list_cross_type","description":"Set membership tests should return false due to the introduction of heterogeneous-equality. Set membership via 'in' is equivalent to the macro exists() behavior.","expr":"'elem' in [1u, 'str', 2, b'bytes']","value":{"boolValue":false}},"ast":"@in(\n \"elem\"^#*expr.Constant_StringValue#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n \"str\"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#,\n b\"bytes\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"elem\"~string,\n [\n 1u~uint,\n \"str\"~string,\n 2~int,\n b\"bytes\"~bytes\n ]~list(dyn)\n)~bool^in_list","type":"bool"}]},{"name":"in_map_literal","tests":[{"original":{"name":"key_not_in_empty_map","expr":"'empty' in {}","value":{"boolValue":false}},"ast":"@in(\n \"empty\"^#*expr.Constant_StringValue#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"empty\"~string,\n {}~map(string, dyn)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_in_map","expr":"'key' in {'key':'1', 'other':'2'}","value":{"boolValue":true}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n \"key\"^#*expr.Constant_StringValue#:\"1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"other\"^#*expr.Constant_StringValue#:\"2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n \"key\"~string:\"1\"~string,\n \"other\"~string:\"2\"~string\n }~map(string, string)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_not_in_map","expr":"'key' in {'lock':1, 'gate':2}","value":{"boolValue":false}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n \"lock\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"gate\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n \"lock\"~string:1~int,\n \"gate\"~string:2~int\n }~map(string, int)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_in_mixed_key_type_map","description":"Map keys are of mixed type, but since the key is present the result is true.","expr":"'key' in {3:3.0, 'key':2u}","value":{"boolValue":true}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n 3^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key\"^#*expr.Constant_StringValue#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n 3~int:3~double,\n \"key\"~string:2u~uint\n }~map(dyn, dyn)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_in_mixed_key_type_map_cross_type","expr":"'key' in {1u:'str', 2:b'bytes'}","value":{"boolValue":false}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n 1u^#*expr.Constant_Uint64Value#:\"str\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:b\"bytes\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n 1u~uint:\"str\"~string,\n 2~int:b\"bytes\"~bytes\n }~map(dyn, dyn)\n)~bool^in_map","type":"bool"}]},{"name":"bound","tests":[{"original":{"name":"bytes_gt_left_false","expr":"x \u003e b'\u0000'","typeEnv":[{"name":"x","ident":{"type":{"primitive":"BYTES"}}}],"bindings":{"x":{"value":{"bytesValue":"AA=="}}},"value":{"boolValue":false}},"ast":"_\u003e_(\n x^#*expr.Expr_IdentExpr#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n x~bytes^x,\n b\"\\x00\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"int_lte_right_true","expr":"123 \u003c= x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"124"}}},"value":{"boolValue":true}},"ast":"_\u003c=_(\n 123^#*expr.Constant_Int64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 123~int,\n x~int^x\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"bool_lt_right_true","expr":"false \u003c x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"x":{"value":{"boolValue":true}}},"value":{"boolValue":true}},"ast":"_\u003c_(\n false^#*expr.Constant_BoolValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n false~bool,\n x~bool^x\n)~bool^less_bool","type":"bool"},{"original":{"name":"double_ne_left_false","expr":"x != 9.8","typeEnv":[{"name":"x","ident":{"type":{"primitive":"DOUBLE"}}}],"bindings":{"x":{"value":{"doubleValue":9.8}}},"value":{"boolValue":false}},"ast":"_!=_(\n x^#*expr.Expr_IdentExpr#,\n 9.8^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n x~double^x,\n 9.8~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"map_ne_right_false","expr":"{'a':'b','c':'d'} != x","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"d"}},{"key":{"stringValue":"a"},"value":{"stringValue":"b"}}]}}}},"value":{"boolValue":false}},"ast":"_!=_(\n {\n \"a\"^#*expr.Constant_StringValue#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"c\"^#*expr.Constant_StringValue#:\"d\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"a\"~string:\"b\"~string,\n \"c\"~string:\"d\"~string\n }~map(string, string),\n x~map(string, string)^x\n)~bool^not_equals","type":"bool"},{"original":{"name":"null_eq_left_true","description":"A comparison _==_ against null only binds if the type is determined to be null or we skip the type checking","expr":"x == null","typeEnv":[{"name":"x","ident":{"type":{"null":null}}}],"bindings":{"x":{"value":{"nullValue":null}}},"value":{"boolValue":true}},"ast":"_==_(\n x^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n x~null^x,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"list_eq_right_false","expr":"[1, 2] == x","typeEnv":[{"name":"x","ident":{"type":{"listType":{"elemType":{"primitive":"INT64"}}}}}],"bindings":{"x":{"value":{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"1"}]}}}},"value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int\n ]~list(int),\n x~list(int)^x\n)~bool^equals","type":"bool"},{"original":{"name":"string_gte_right_true","expr":"'abcd' \u003e= x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"x":{"value":{"stringValue":"abc"}}},"value":{"boolValue":true}},"ast":"_\u003e=_(\n \"abcd\"^#*expr.Constant_StringValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"abcd\"~string,\n x~string^x\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"uint_eq_right_false","expr":"999u == x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"UINT64"}}}],"bindings":{"x":{"value":{"uint64Value":"1000"}}},"value":{"boolValue":false}},"ast":"_==_(\n 999u^#*expr.Constant_Uint64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 999u~uint,\n x~uint^x\n)~bool^equals","type":"bool"},{"original":{"name":"null_lt_right_no_such_overload","description":"There is no _\u003c_ operation for null, even if both operands are null","expr":"null \u003c x","disableCheck":true,"bindings":{"x":{"value":{"nullValue":null}}},"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n null^#*expr.Constant_NullValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:8: undeclared reference to 'x' (in container '')\n | null \u003c x\n | .......^"}]}]},{"name":"conversions","suites":[{"name":"bytes","tests":[{"original":{"name":"string_empty","expr":"bytes('')","value":{"bytesValue":""}},"ast":"bytes(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n \"\"~string\n)~bytes^string_to_bytes","type":"bytes"},{"original":{"name":"string","expr":"bytes('abc')","value":{"bytesValue":"YWJj"}},"ast":"bytes(\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n \"abc\"~string\n)~bytes^string_to_bytes","type":"bytes"},{"original":{"name":"string_unicode","expr":"bytes('ÿ')","value":{"bytesValue":"w78="}},"ast":"bytes(\n \"ÿ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n \"ÿ\"~string\n)~bytes^string_to_bytes","type":"bytes"},{"original":{"name":"string_unicode_vs_literal","expr":"bytes('\\377') == b'\\377'","value":{"boolValue":false}},"ast":"_==_(\n bytes(\n \"ÿ\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n b\"\\xff\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n bytes(\n \"ÿ\"~string\n )~bytes^string_to_bytes,\n b\"\\xff\"~bytes\n)~bool^equals","type":"bool"}]},{"name":"double","tests":[{"original":{"name":"int_zero","expr":"double(0)","value":{"doubleValue":0}},"ast":"double(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 0~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_pos","expr":"double(1000000000000)","value":{"doubleValue":1000000000000}},"ast":"double(\n 1000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 1000000000000~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_neg","expr":"double(-1000000000000000)","value":{"doubleValue":-1000000000000000}},"ast":"double(\n -1000000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n -1000000000000000~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_min_exact","description":"Smallest contiguous representable int (-2^53).","expr":"double(-9007199254740992)","value":{"doubleValue":-9007199254740992}},"ast":"double(\n -9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n -9007199254740992~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_max_exact","description":"Largest contiguous representable int (2^53).","expr":"double(9007199254740992)","value":{"doubleValue":9007199254740992}},"ast":"double(\n 9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 9007199254740992~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_range","description":"Largest signed 64-bit. Rounds to nearest double.","expr":"double(9223372036854775807)","value":{"doubleValue":9223372036854776000}},"ast":"double(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 9223372036854775807~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"uint_zero","expr":"double(0u)","value":{"doubleValue":0}},"ast":"double(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 0u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"uint_pos","expr":"double(123u)","value":{"doubleValue":123}},"ast":"double(\n 123u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 123u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"uint_max_exact","description":"Largest contiguous representable int (2^53).","expr":"double(9007199254740992u)","value":{"doubleValue":9007199254740992}},"ast":"double(\n 9007199254740992u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 9007199254740992u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"uint_range","description":"Largest unsigned 64-bit.","expr":"double(18446744073709551615u)","value":{"doubleValue":18446744073709552000}},"ast":"double(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 18446744073709551615u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"string_zero","expr":"double('0')","value":{"doubleValue":0}},"ast":"double(\n \"0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"0\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_zero_dec","expr":"double('0.0')","value":{"doubleValue":0}},"ast":"double(\n \"0.0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"0.0\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_neg_zero","expr":"double('-0.0')","value":{"doubleValue":0}},"ast":"double(\n \"-0.0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-0.0\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_no_dec","expr":"double('123')","value":{"doubleValue":123}},"ast":"double(\n \"123\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"123\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_pos","expr":"double('123.456')","value":{"doubleValue":123.456}},"ast":"double(\n \"123.456\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"123.456\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_neg","expr":"double('-987.654')","value":{"doubleValue":-987.654}},"ast":"double(\n \"-987.654\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-987.654\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_pos_pos","expr":"double('6.02214e23')","value":{"doubleValue":6.02214e+23}},"ast":"double(\n \"6.02214e23\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"6.02214e23\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_pos_neg","expr":"double('1.38e-23')","value":{"doubleValue":1.38e-23}},"ast":"double(\n \"1.38e-23\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"1.38e-23\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_neg_pos","expr":"double('-84.32e7')","value":{"doubleValue":-843200000}},"ast":"double(\n \"-84.32e7\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-84.32e7\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_neg_neg","expr":"double('-5.43e-21')","value":{"doubleValue":-5.43e-21}},"ast":"double(\n \"-5.43e-21\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-5.43e-21\"~string\n)~double^string_to_double","type":"double"}]},{"name":"dyn","tests":[{"original":{"name":"dyn_heterogeneous_list","description":"No need to disable type checking.","expr":"type(dyn([1, 'one']))","value":{"typeValue":"list"}},"ast":"type(\n dyn(\n [\n 1^#*expr.Constant_Int64Value#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n dyn(\n [\n 1~int,\n \"one\"~string\n ]~list(dyn)\n )~dyn^to_dyn\n)~type(dyn)^type","type":"type(dyn)"}]},{"name":"int","tests":[{"original":{"name":"uint","expr":"int(42u)","value":{"int64Value":"42"}},"ast":"int(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 42u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"uint_zero","expr":"int(0u)","value":{"int64Value":"0"}},"ast":"int(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 0u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"uint_max_exact","expr":"int(9223372036854775807u)","value":{"int64Value":"9223372036854775807"}},"ast":"int(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 9223372036854775807u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"uint_range","expr":"int(18446744073709551615u)","evalError":{"errors":[{"message":"range error"}]}},"ast":"int(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 18446744073709551615u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"double_round_neg","expr":"int(-123.456)","value":{"int64Value":"-123"}},"ast":"int(\n -123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -123.456~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_truncate","expr":"int(1.9)","value":{"int64Value":"1"}},"ast":"int(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1.9~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_truncate_neg","expr":"int(-7.9)","value":{"int64Value":"-7"}},"ast":"int(\n -7.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -7.9~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_half_pos","expr":"int(11.5)","value":{"int64Value":"11"}},"ast":"int(\n 11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 11.5~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_half_neg","expr":"int(-3.5)","value":{"int64Value":"-3"}},"ast":"int(\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -3.5~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_big_exact","description":"Beyond exact range (2^53), but no loss of precision (2^55).","expr":"int(double(36028797018963968))","value":{"int64Value":"36028797018963968"}},"ast":"int(\n double(\n 36028797018963968^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n double(\n 36028797018963968~int\n )~double^int64_to_double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_big_precision","description":"Beyond exact range (2^53), but loses precision (2^55 + 1).","expr":"int(double(36028797018963969))","value":{"int64Value":"36028797018963968"}},"ast":"int(\n double(\n 36028797018963969^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n double(\n 36028797018963969~int\n )~double^int64_to_double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_int_max_range","description":"The double(2^63-1) cast produces a floating point value outside the int range","expr":"int(9223372036854775807.0)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 9.223372036854776e+18~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_int_min_range","description":"The double(-2^63) cast produces a floating point value outside the int range","expr":"int(-9223372036854775808.0)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -9.223372036854776e+18~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_range","expr":"int(1e99)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n 1e+99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1e+99~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"string","expr":"int('987')","value":{"int64Value":"987"}},"ast":"int(\n \"987\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n \"987\"~string\n)~int^string_to_int64","type":"int"},{"original":{"name":"timestamp","expr":"int(timestamp('2004-09-16T23:59:59Z'))","value":{"int64Value":"1095379199"}},"ast":"int(\n timestamp(\n \"2004-09-16T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n timestamp(\n \"2004-09-16T23:59:59Z\"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64","type":"int"}]},{"name":"string","tests":[{"original":{"name":"int","expr":"string(123)","value":{"stringValue":"123"}},"ast":"string(\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n 123~int\n)~string^int64_to_string","type":"string"},{"original":{"name":"int_neg","expr":"string(-456)","value":{"stringValue":"-456"}},"ast":"string(\n -456^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n -456~int\n)~string^int64_to_string","type":"string"},{"original":{"name":"uint","expr":"string(9876u)","value":{"stringValue":"9876"}},"ast":"string(\n 9876u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n 9876u~uint\n)~string^uint64_to_string","type":"string"},{"original":{"name":"double","expr":"string(123.456)","value":{"stringValue":"123.456"}},"ast":"string(\n 123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n 123.456~double\n)~string^double_to_string","type":"string"},{"original":{"name":"double_hard","expr":"string(-4.5e-3)","value":{"stringValue":"-0.0045"}},"ast":"string(\n -0.0045^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n -0.0045~double\n)~string^double_to_string","type":"string"},{"original":{"name":"bytes","expr":"string(b'abc')","value":{"stringValue":"abc"}},"ast":"string(\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n b\"abc\"~bytes\n)~string^bytes_to_string","type":"string"},{"original":{"name":"bytes_unicode","expr":"string(b'\\303\\277')","value":{"stringValue":"ÿ"}},"ast":"string(\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n b\"ÿ\"~bytes\n)~string^bytes_to_string","type":"string"},{"original":{"name":"bytes_invalid","expr":"string(b'\\000\\xff')","evalError":{"errors":[{"message":"invalid UTF-8"}]}},"ast":"string(\n b\"\\x00\\xff\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n b\"\\x00\\xff\"~bytes\n)~string^bytes_to_string","type":"string"}]},{"name":"type","tests":[{"original":{"name":"bool","expr":"type(true)","value":{"typeValue":"bool"}},"ast":"type(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n true~bool\n)~type(bool)^type","type":"type(bool)"},{"original":{"name":"bool_denotation","expr":"bool","value":{"typeValue":"bool"}},"ast":"bool^#*expr.Expr_IdentExpr#","checkedAst":"bool~type(bool)^bool","type":"type(bool)"},{"original":{"name":"dyn_no_denotation","expr":"dyn","disableCheck":true,"evalError":{"errors":[{"message":"unknown variable"}]}},"ast":"dyn^#*expr.Expr_IdentExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'dyn' (in container '')\n | dyn\n | ^"},{"original":{"name":"int","expr":"type(0)","value":{"typeValue":"int"}},"ast":"type(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n 0~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"int_denotation","expr":"int","value":{"typeValue":"int"}},"ast":"int^#*expr.Expr_IdentExpr#","checkedAst":"int~type(int)^int","type":"type(int)"},{"original":{"name":"eq_same","expr":"type(true) == type(false)","value":{"boolValue":true}},"ast":"_==_(\n type(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n type(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n true~bool\n )~type(bool)^type,\n type(\n false~bool\n )~type(bool)^type\n)~bool^equals","type":"bool"},{"original":{"name":"uint","expr":"type(64u)","value":{"typeValue":"uint"}},"ast":"type(\n 64u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n 64u~uint\n)~type(uint)^type","type":"type(uint)"},{"original":{"name":"uint_denotation","expr":"uint","value":{"typeValue":"uint"}},"ast":"uint^#*expr.Expr_IdentExpr#","checkedAst":"uint~type(uint)^uint","type":"type(uint)"},{"original":{"name":"double","expr":"type(3.14)","value":{"typeValue":"double"}},"ast":"type(\n 3.14^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n 3.14~double\n)~type(double)^type","type":"type(double)"},{"original":{"name":"double_denotation","expr":"double","value":{"typeValue":"double"}},"ast":"double^#*expr.Expr_IdentExpr#","checkedAst":"double~type(double)^double","type":"type(double)"},{"original":{"name":"null_type","expr":"type(null)","value":{"typeValue":"null_type"}},"ast":"type(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n null~null\n)~type(null)^type","type":"type(null)"},{"original":{"name":"null_type_denotation","expr":"null_type","value":{"typeValue":"null_type"}},"ast":"null_type^#*expr.Expr_IdentExpr#","checkedAst":"null_type~type(null)^null_type","type":"type(null)"},{"original":{"name":"string","expr":"type('foo')","value":{"typeValue":"string"}},"ast":"type(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n \"foo\"~string\n)~type(string)^type","type":"type(string)"},{"original":{"name":"string_denotation","expr":"string","value":{"typeValue":"string"}},"ast":"string^#*expr.Expr_IdentExpr#","checkedAst":"string~type(string)^string","type":"type(string)"},{"original":{"name":"bytes","expr":"type(b'\\xff')","value":{"typeValue":"bytes"}},"ast":"type(\n b\"\\xff\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n b\"\\xff\"~bytes\n)~type(bytes)^type","type":"type(bytes)"},{"original":{"name":"bytes_denotation","expr":"bytes","value":{"typeValue":"bytes"}},"ast":"bytes^#*expr.Expr_IdentExpr#","checkedAst":"bytes~type(bytes)^bytes","type":"type(bytes)"},{"original":{"name":"list","expr":"type([1, 2, 3])","value":{"typeValue":"list"}},"ast":"type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~type(list(int))^type","type":"type(list(int))"},{"original":{"name":"list_denotation","expr":"list","value":{"typeValue":"list"}},"ast":"list^#*expr.Expr_IdentExpr#","checkedAst":"list~type(list(dyn))^list","type":"type(list(dyn))"},{"original":{"name":"lists_monomorphic","expr":"type([1, 2, 3]) == type(['one', 'two', 'three'])","value":{"boolValue":true}},"ast":"_==_(\n type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n [\n \"one\"^#*expr.Constant_StringValue#,\n \"two\"^#*expr.Constant_StringValue#,\n \"three\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n )~type(list(int))^type,\n type(\n [\n \"one\"~string,\n \"two\"~string,\n \"three\"~string\n ]~list(string)\n )~type(list(string))^type\n)~bool^equals","type":"bool"},{"original":{"name":"map","expr":"type({4: 16})","value":{"typeValue":"map"}},"ast":"type(\n {\n 4^#*expr.Constant_Int64Value#:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n {\n 4~int:16~int\n }~map(int, int)\n)~type(map(int, int))^type","type":"type(map(int, int))"},{"original":{"name":"map_denotation","expr":"map","value":{"typeValue":"map"}},"ast":"map^#*expr.Expr_IdentExpr#","checkedAst":"map~type(map(dyn, dyn))^map","type":"type(map(dyn, dyn))"},{"original":{"name":"map_monomorphic","expr":"type({'one': 1}) == type({1: 'one'})","value":{"boolValue":true}},"ast":"_==_(\n type(\n {\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n {\n 1^#*expr.Constant_Int64Value#:\"one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n {\n \"one\"~string:1~int\n }~map(string, int)\n )~type(map(string, int))^type,\n type(\n {\n 1~int:\"one\"~string\n }~map(int, string)\n )~type(map(int, string))^type\n)~bool^equals","type":"bool"},{"original":{"name":"eq_diff","expr":"type(7) == type(7u)","value":{"boolValue":false}},"ast":"_==_(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n 7~int\n )~type(int)^type,\n type(\n 7u~uint\n )~type(uint)^type\n)~bool^equals","type":"bool"},{"original":{"name":"neq_same","expr":"type(0.0) != type(-0.0)","value":{"boolValue":false}},"ast":"_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n -0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n -0~double\n )~type(double)^type\n)~bool^not_equals","type":"bool"},{"original":{"name":"neq_diff","expr":"type(0.0) != type(0)","value":{"boolValue":true}},"ast":"_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n 0~int\n )~type(int)^type\n)~bool^not_equals","type":"bool"},{"original":{"name":"meta","expr":"type(type(7)) == type(type(7u))","value":{"boolValue":true}},"ast":"_==_(\n type(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n type(\n 7~int\n )~type(int)^type\n )~type(type(int))^type,\n type(\n type(\n 7u~uint\n )~type(uint)^type\n )~type(type(uint))^type\n)~bool^equals","type":"bool"},{"original":{"name":"type","expr":"type(int)","value":{"typeValue":"type"}},"ast":"type(\n int^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n int~type(int)^int\n)~type(type(int))^type","type":"type(type(int))"},{"original":{"name":"type_denotation","expr":"type","value":{"typeValue":"type"}},"ast":"type^#*expr.Expr_IdentExpr#","checkedAst":"type~type(type)^type","type":"type(type)"},{"original":{"name":"type_type","expr":"type(type)","value":{"typeValue":"type"}},"ast":"type(\n type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n type~type(type)^type\n)~type(type(type))^type","type":"type(type(type))"}]},{"name":"uint","tests":[{"original":{"name":"int","expr":"uint(1729)","value":{"uint64Value":"1729"}},"ast":"uint(\n 1729^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 1729~int\n)~uint^int64_to_uint64","type":"uint"},{"original":{"name":"int_max","expr":"uint(9223372036854775807)","value":{"uint64Value":"9223372036854775807"}},"ast":"uint(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 9223372036854775807~int\n)~uint^int64_to_uint64","type":"uint"},{"original":{"name":"int_neg","expr":"uint(-1)","evalError":{"errors":[{"message":"range"}]}},"ast":"uint(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n -1~int\n)~uint^int64_to_uint64","type":"uint"},{"original":{"name":"double","expr":"uint(3.14159265)","value":{"uint64Value":"3"}},"ast":"uint(\n 3.14159265^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 3.14159265~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_truncate","expr":"uint(1.9)","value":{"uint64Value":"1"}},"ast":"uint(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 1.9~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_half","expr":"uint(25.5)","value":{"uint64Value":"25"}},"ast":"uint(\n 25.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 25.5~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_big_exact","description":"Beyond exact range (2^53), but no loss of precision (2^55).","expr":"uint(double(36028797018963968u))","value":{"uint64Value":"36028797018963968"}},"ast":"uint(\n double(\n 36028797018963968u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n double(\n 36028797018963968u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_big_precision","description":"Beyond exact range (2^53), but loses precision (2^55 + 1).","expr":"uint(double(36028797018963969u))","value":{"uint64Value":"36028797018963968"}},"ast":"uint(\n double(\n 36028797018963969u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n double(\n 36028797018963969u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_uint_max_range","description":"The exact conversion of uint max as a double does not round trip.","expr":"int(18446744073709551615.0)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n 1.8446744073709552e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1.8446744073709552e+19~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_range_beyond_uint","expr":"uint(6.022e23)","evalError":{"errors":[{"message":"range"}]}},"ast":"uint(\n 6.022e+23^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 6.022e+23~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"string","expr":"uint('300')","value":{"uint64Value":"300"}},"ast":"uint(\n \"300\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n \"300\"~string\n)~uint^string_to_uint64","type":"uint"}]},{"name":"bool","tests":[{"original":{"name":"string_1","expr":"bool('1')","value":{"boolValue":true}},"ast":"bool(\n \"1\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"1\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_t","expr":"bool('t')","value":{"boolValue":true}},"ast":"bool(\n \"t\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"t\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_lowercase","expr":"bool('true')","value":{"boolValue":true}},"ast":"bool(\n \"true\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"true\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_uppercase","expr":"bool('TRUE')","value":{"boolValue":true}},"ast":"bool(\n \"TRUE\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"TRUE\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_pascalcase","expr":"bool('True')","value":{"boolValue":true}},"ast":"bool(\n \"True\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"True\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_0","expr":"bool('0')","value":{"boolValue":false}},"ast":"bool(\n \"0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"0\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_f","expr":"bool('f')","value":{"boolValue":false}},"ast":"bool(\n \"f\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"f\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_lowercase","expr":"bool('false')","value":{"boolValue":false}},"ast":"bool(\n \"false\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"false\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_uppercase","expr":"bool('FALSE')","value":{"boolValue":false}},"ast":"bool(\n \"FALSE\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"FALSE\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_pascalcase","expr":"bool('False')","value":{"boolValue":false}},"ast":"bool(\n \"False\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"False\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_badcase","expr":"bool('TrUe')","evalError":{"errors":[{"message":"Type conversion error"}]}},"ast":"bool(\n \"TrUe\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"TrUe\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_badcase","expr":"bool('FaLsE')","evalError":{"errors":[{"message":"Type conversion error"}]}},"ast":"bool(\n \"FaLsE\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"FaLsE\"~string\n)~bool^string_to_bool","type":"bool"}]},{"name":"identity","tests":[{"original":{"name":"bool","expr":"bool(true)","value":{"boolValue":true}},"ast":"bool(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n true~bool\n)~bool^bool_to_bool","type":"bool"},{"original":{"name":"int","expr":"int(1)","value":{"int64Value":"1"}},"ast":"int(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1~int\n)~int^int64_to_int64","type":"int"},{"original":{"name":"uint","expr":"uint(1u)","value":{"uint64Value":"1"}},"ast":"uint(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 1u~uint\n)~uint^uint64_to_uint64","type":"uint"},{"original":{"name":"double","expr":"double(5.5)","value":{"doubleValue":5.5}},"ast":"double(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 5.5~double\n)~double^double_to_double","type":"double"},{"original":{"name":"string","expr":"string('hello')","value":{"stringValue":"hello"}},"ast":"string(\n \"hello\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n \"hello\"~string\n)~string^string_to_string","type":"string"},{"original":{"name":"bytes","expr":"bytes(b'abc')","value":{"bytesValue":"YWJj"}},"ast":"bytes(\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n b\"abc\"~bytes\n)~bytes^bytes_to_bytes","type":"bytes"},{"original":{"name":"duration","expr":"duration(duration('100s')) == duration('100s')","value":{"boolValue":true}},"ast":"_==_(\n duration(\n duration(\n \"100s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"100s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n duration(\n duration(\n \"100s\"~string\n )~duration^string_to_duration\n )~duration^duration_to_duration,\n duration(\n \"100s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"timestamp","expr":"timestamp(timestamp(1000000000)) == timestamp(1000000000)","value":{"boolValue":true}},"ast":"_==_(\n timestamp(\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n timestamp(\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n )~timestamp^timestamp_to_timestamp,\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n)~bool^equals","type":"bool"}]}]},{"name":"dynamic","suites":[{"name":"int32","tests":[{"original":{"name":"literal","expr":"google.protobuf.Int32Value{value: -123}","value":{"int64Value":"-123"}},"ast":"google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int32Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int32Value","type":"wrapper(int)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Int32Value{value: -123}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int32Value{value: -123}.value\n | .......................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.Int32Value{}","value":{"int64Value":"0"}},"ast":"google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value","type":"wrapper(int)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Int32Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Int32Value","value":2000000}}}},"value":{"int64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(int)^x","type":"wrapper(int)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_int32_wrapper: 432}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":432}}},"ast":"TestAllTypes{\n single_int32_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_int32_wrapper: 0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":0}}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_max","expr":"TestAllTypes{single_int32_wrapper: 2147483647}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":2147483647}}},"ast":"TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_min","expr":"TestAllTypes{single_int32_wrapper: -2147483648}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":-2147483648}}},"ast":"TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","expr":"TestAllTypes{single_int32_wrapper: 12345678900}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_int32_wrapper:12345678900^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:12345678900~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"int64Value":"642"}},"ast":"TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_int32_wrapper: -975}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":-975}}},"ast":"TestAllTypes{\n single_int32_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_int32_wrapper: 0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":0}}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_max","expr":"TestAllTypes{single_int32_wrapper: 2147483647}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":2147483647}}},"ast":"TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_min","expr":"TestAllTypes{single_int32_wrapper: -2147483648}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":-2147483648}}},"ast":"TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","expr":"TestAllTypes{single_int32_wrapper: -998877665544332211}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_int32_wrapper:-998877665544332211^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-998877665544332211~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper","container":"cel.expr.conformance.proto3","value":{"int64Value":"642"}},"ast":"TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_int32_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"}]},{"name":"int64","tests":[{"original":{"name":"literal","expr":"google.protobuf.Int64Value{value: -123}","value":{"int64Value":"-123"}},"ast":"google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int64Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int64Value","type":"wrapper(int)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Int64Value{value: -123}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int64Value{value: -123}.value\n | .......................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.Int64Value{}","value":{"int64Value":"0"}},"ast":"google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value","type":"wrapper(int)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Int64Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Int64Value","value":"2000000"}}}},"value":{"int64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(int)^x","type":"wrapper(int)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_int64_wrapper: 432}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64Wrapper":"432"}}},"ast":"TestAllTypes{\n single_int64_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_int64_wrapper: 0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_int64_wrapper: -975}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64Wrapper":"-975"}}},"ast":"TestAllTypes{\n single_int64_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_int64_wrapper: 0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"uint32","tests":[{"original":{"name":"literal","expr":"google.protobuf.UInt32Value{value: 123u}","value":{"uint64Value":"123"}},"ast":"google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt32Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt32Value","type":"wrapper(uint)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.UInt32Value{value: 123u}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt32Value{value: 123u}.value\n | ........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.UInt32Value{}","value":{"uint64Value":"0"}},"ast":"google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value","type":"wrapper(uint)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.UInt32Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.UInt32Value","value":2000000}}}},"value":{"uint64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(uint)^x","type":"wrapper(uint)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_uint32_wrapper: 432u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":432}}},"ast":"TestAllTypes{\n single_uint32_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_uint32_wrapper: 0u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":0}}},"ast":"TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_max","expr":"TestAllTypes{single_uint32_wrapper: 4294967295u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":4294967295}}},"ast":"TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","expr":"TestAllTypes{single_uint32_wrapper: 6111222333u}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_uint32_wrapper: 975u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":975}}},"ast":"TestAllTypes{\n single_uint32_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_uint32_wrapper: 0u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":0}}},"ast":"TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_max","expr":"TestAllTypes{single_uint32_wrapper: 4294967295u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":4294967295}}},"ast":"TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","expr":"TestAllTypes{single_uint32_wrapper: 6111222333u}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_uint32_wrapper: 258u}.single_uint32_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"258"}},"ast":"TestAllTypes{\n single_uint32_wrapper:258u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:258u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_uint32_wrapper: 0u}.single_uint32_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"0"}},"ast":"TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_uint32_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)","type":"wrapper(uint)"}]},{"name":"uint64","tests":[{"original":{"name":"literal","expr":"google.protobuf.UInt64Value{value: 123u}","value":{"uint64Value":"123"}},"ast":"google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt64Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt64Value","type":"wrapper(uint)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.UInt64Value{value: 123u}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt64Value{value: 123u}.value\n | ........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.UInt64Value{}","value":{"uint64Value":"0"}},"ast":"google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value","type":"wrapper(uint)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.UInt64Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.UInt64Value","value":"2000000"}}}},"value":{"uint64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(uint)^x","type":"wrapper(uint)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_uint64_wrapper: 432u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64Wrapper":"432"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_uint64_wrapper: 0u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_uint64_wrapper: 975u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64Wrapper":"975"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_uint64_wrapper: 0u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_uint64_wrapper: 5123123123u}.single_uint64_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"5123123123"}},"ast":"TestAllTypes{\n single_uint64_wrapper:5123123123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:5123123123u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_uint64_wrapper: 0u}.single_uint64_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"0"}},"ast":"TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_uint64_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)","type":"wrapper(uint)"}]},{"name":"float","tests":[{"original":{"name":"literal","expr":"google.protobuf.FloatValue{value: -1.5e3}","value":{"doubleValue":-1500}},"ast":"google.protobuf.FloatValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.FloatValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.FloatValue","type":"wrapper(double)"},{"original":{"name":"literal_not_double","description":"Use a number with no exact representation to make sure we actually narrow to a float.","expr":"google.protobuf.FloatValue{value: 1.333} == 1.333","value":{"boolValue":false}},"ast":"_==_(\n google.protobuf.FloatValue{\n value:1.333^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1.333^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:1.333~double\n }~wrapper(double)^google.protobuf.FloatValue,\n 1.333~double\n)~bool^equals","type":"bool"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.FloatValue{value: 3.1416}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.FloatValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:42: type 'wrapper(double)' does not support field selection\n | google.protobuf.FloatValue{value: 3.1416}.value\n | .........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.FloatValue{}","value":{"doubleValue":0}},"ast":"google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue","type":"wrapper(double)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.FloatValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.FloatValue","value":-1250000}}}},"value":{"doubleValue":-1250000}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(double)^x","type":"wrapper(double)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_float_wrapper: 86.75}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":86.75}}},"ast":"TestAllTypes{\n single_float_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_subnorm","description":"Subnormal single floats range from ~1e-38 to ~1e-45.","expr":"TestAllTypes{single_float_wrapper: 1e-40}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":1e-40}}},"ast":"TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_round_to_zero","description":"Subnormal single floats range from ~1e-38 to ~1e-45.","expr":"TestAllTypes{single_float_wrapper: 1e-50}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:1e-50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-50~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","description":"Single float max is about 3.4e38","expr":"TestAllTypes{single_float_wrapper: 1.4e55}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":"Infinity"}}},"ast":"TestAllTypes{\n single_float_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_float_wrapper: -12.375}.single_float_wrapper","container":"cel.expr.conformance.proto2","value":{"doubleValue":-12.375}},"ast":"TestAllTypes{\n single_float_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper","container":"cel.expr.conformance.proto2","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_float_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_float_wrapper: -9.75}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":-9.75}}},"ast":"TestAllTypes{\n single_float_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto2_subnorm","description":"Subnormal single floats range from ~1e-38 to ~1e-45.","expr":"TestAllTypes{single_float_wrapper: 1e-40}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":1e-40}}},"ast":"TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3_round_to_zero","expr":"TestAllTypes{single_float_wrapper: -9.9e-100}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:-9.9e-100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e-100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","description":"Single float min is about -3.4e38","expr":"TestAllTypes{single_float_wrapper: -9.9e100}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":"-Infinity"}}},"ast":"TestAllTypes{\n single_float_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_float_wrapper: 64.25}.single_float_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":64.25}},"ast":"TestAllTypes{\n single_float_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_float_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"}]},{"name":"double","tests":[{"original":{"name":"literal","expr":"google.protobuf.DoubleValue{value: -1.5e3}","value":{"doubleValue":-1500}},"ast":"google.protobuf.DoubleValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.DoubleValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.DoubleValue","type":"wrapper(double)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.DoubleValue{value: 3.1416}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.DoubleValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:43: type 'wrapper(double)' does not support field selection\n | google.protobuf.DoubleValue{value: 3.1416}.value\n | ..........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.DoubleValue{}","value":{"doubleValue":0}},"ast":"google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue","type":"wrapper(double)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.DoubleValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.DoubleValue","value":-1250000}}}},"value":{"doubleValue":-1250000}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(double)^x","type":"wrapper(double)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_double_wrapper: 86.75}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":86.75}}},"ast":"TestAllTypes{\n single_double_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_double_wrapper: 0.0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":0}}},"ast":"TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","expr":"TestAllTypes{single_double_wrapper: 1.4e55}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":1.4e+55}}},"ast":"TestAllTypes{\n single_double_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_double_wrapper: -12.375}.single_double_wrapper","container":"cel.expr.conformance.proto2","value":{"doubleValue":-12.375}},"ast":"TestAllTypes{\n single_double_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_double_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_double_wrapper: -9.75}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":-9.75}}},"ast":"TestAllTypes{\n single_double_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_double_wrapper: 0.0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":0}}},"ast":"TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","expr":"TestAllTypes{single_double_wrapper: -9.9e100}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":-9.9e+100}}},"ast":"TestAllTypes{\n single_double_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_double_wrapper: 64.25}.single_double_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":64.25}},"ast":"TestAllTypes{\n single_double_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_double_wrapper: 0.0}.single_double_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_double_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"}]},{"name":"bool","tests":[{"original":{"name":"literal","expr":"google.protobuf.BoolValue{value: true}","value":{"boolValue":true}},"ast":"google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BoolValue{\n value:true~bool\n}~wrapper(bool)^google.protobuf.BoolValue","type":"wrapper(bool)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.BoolValue{value: true}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:39: type 'wrapper(bool)' does not support field selection\n | google.protobuf.BoolValue{value: true}.value\n | ......................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.BoolValue{}","value":{"boolValue":false}},"ast":"google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue","type":"wrapper(bool)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.BoolValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.BoolValue","value":true}}}},"value":{"boolValue":true}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(bool)^x","type":"wrapper(bool)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_false","expr":"TestAllTypes{single_bool_wrapper: false}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBoolWrapper":false}}},"ast":"TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_false","expr":"TestAllTypes{single_bool_wrapper: false}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBoolWrapper":false}}},"ast":"TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"string","tests":[{"original":{"name":"literal","expr":"google.protobuf.StringValue{value: 'foo'}","value":{"stringValue":"foo"}},"ast":"google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.StringValue{\n value:\"foo\"~string\n}~wrapper(string)^google.protobuf.StringValue","type":"wrapper(string)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.StringValue{value: 'foo'}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:42: type 'wrapper(string)' does not support field selection\n | google.protobuf.StringValue{value: 'foo'}.value\n | .........................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.StringValue{}","value":{"stringValue":""}},"ast":"google.protobuf.StringValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue","type":"wrapper(string)"},{"original":{"name":"literal_unicode","expr":"google.protobuf.StringValue{value: 'flambé'}","value":{"stringValue":"flambé"}},"ast":"google.protobuf.StringValue{\n value:\"flambé\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.StringValue{\n value:\"flambé\"~string\n}~wrapper(string)^google.protobuf.StringValue","type":"wrapper(string)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.StringValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.StringValue","value":"bar"}}}},"value":{"stringValue":"bar"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(string)^x","type":"wrapper(string)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_string_wrapper: 'baz'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStringWrapper":"baz"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"baz\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:\"baz\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_string_wrapper: ''}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStringWrapper":""}}},"ast":"TestAllTypes{\n single_string_wrapper:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:\"\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_string_wrapper: 'bletch'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStringWrapper":"bletch"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"bletch\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:\"bletch\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_string_wrapper: ''}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStringWrapper":""}}},"ast":"TestAllTypes{\n single_string_wrapper:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:\"\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"bytes","tests":[{"original":{"name":"literal","expr":"google.protobuf.BytesValue{value: b'foo\\123'}","value":{"bytesValue":"Zm9vUw=="}},"ast":"google.protobuf.BytesValue{\n value:b\"fooS\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BytesValue{\n value:b\"fooS\"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue","type":"wrapper(bytes)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.BytesValue{value: b'foo'}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.BytesValue{\n value:b\"foo\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:42: type 'wrapper(bytes)' does not support field selection\n | google.protobuf.BytesValue{value: b'foo'}.value\n | .........................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.BytesValue{}","value":{"bytesValue":""}},"ast":"google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue","type":"wrapper(bytes)"},{"original":{"name":"literal_unicode","expr":"google.protobuf.BytesValue{value: b'flambé'}","value":{"bytesValue":"ZmxhbWLDqQ=="}},"ast":"google.protobuf.BytesValue{\n value:b\"flambé\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BytesValue{\n value:b\"flambé\"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue","type":"wrapper(bytes)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.BytesValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.BytesValue","value":"YmFy"}}}},"value":{"bytesValue":"YmFy"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(bytes)^x","type":"wrapper(bytes)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_bytes_wrapper: b'baz'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytesWrapper":"YmF6"}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"baz\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b\"baz\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_bytes_wrapper: b''}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytesWrapper":""}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b\"\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_bytes_wrapper: b'bletch'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytesWrapper":"YmxldGNo"}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"bletch\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b\"bletch\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_bytes_wrapper: b''}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytesWrapper":""}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b\"\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"list","tests":[{"original":{"name":"literal","expr":"google.protobuf.ListValue{values: [3.0, 'foo', null]}","value":{"listValue":{"values":[{"doubleValue":3},{"stringValue":"foo"},{"nullValue":null}]}}},"ast":"google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.ListValue{\n values:[\n 3~double,\n \"foo\"~string,\n null~null\n ]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue","type":"list(dyn)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.ListValue{values: [3.0, 'foo', null]}.values","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.values^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:54: type 'list(dyn)' does not support field selection\n | google.protobuf.ListValue{values: [3.0, 'foo', null]}.values\n | .....................................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.ListValue{values: []}","value":{"listValue":{}}},"ast":"google.protobuf.ListValue{\n values:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.ListValue{\n values:[]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue","type":"list(dyn)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.ListValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.ListValue","value":["bar",["a","b"]]}}}},"value":{"listValue":{"values":[{"stringValue":"bar"},{"listValue":{"values":[{"stringValue":"a"},{"stringValue":"b"}]}}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~list(dyn)^x","type":"list(dyn)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{list_value: [1.0, 'one']}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","listValue":[1,"one"]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{list_value: []}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","listValue":[]}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{list_value: [1.0, 'one']}.list_value","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"doubleValue":1},{"stringValue":"one"}]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{list_value: []}.list_value","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto2_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.list_value","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{list_value: [1.0, 'one']}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","listValue":[1,"one"]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{list_value: []}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","listValue":[]}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{list_value: [1.0, 'one']}.list_value","container":"cel.expr.conformance.proto3","value":{"listValue":{"values":[{"doubleValue":1},{"stringValue":"one"}]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{list_value: []}.list_value","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto3_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.list_value","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"}]},{"name":"struct","tests":[{"original":{"name":"literal","expr":"google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}","value":{"mapValue":{"entries":[{"key":{"stringValue":"uno"},"value":{"doubleValue":1}},{"key":{"stringValue":"dos"},"value":{"doubleValue":2}}]}}},"ast":"google.protobuf.Struct{\n fields:{\n \"uno\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"dos\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Struct{\n fields:{\n \"uno\"~string:1~double,\n \"dos\"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct","type":"map(string, dyn)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}.fields","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Struct{\n fields:{\n \"uno\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"dos\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.fields^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Struct{\n fields:{\n \"uno\"~string:1~double,\n \"dos\"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct.fields~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Struct{fields: {}}","value":{"mapValue":{}}},"ast":"google.protobuf.Struct{\n fields:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Struct{\n fields:{}~map(string, dyn)\n}~map(string, dyn)^google.protobuf.Struct","type":"map(string, dyn)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Struct"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Struct","value":{"first":"Abraham","last":"Lincoln"}}}}},"value":{"mapValue":{"entries":[{"key":{"stringValue":"first"},"value":{"stringValue":"Abraham"}},{"key":{"stringValue":"last"},"value":{"stringValue":"Lincoln"}}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~map(string, dyn)^x","type":"map(string, dyn)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStruct":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_struct:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_struct: {}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStruct":{}}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_bad","expr":"TestAllTypes{single_struct: {1: 'uno'}}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"bad key type"}]}},"ast":"TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_struct: {'one': 1.0}}.single_struct","container":"cel.expr.conformance.proto2","value":{"mapValue":{"entries":[{"key":{"stringValue":"one"},"value":{"doubleValue":1}}]}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n \"one\"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{single_struct: {}}.single_struct","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto2_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.single_struct","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStruct":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_struct:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_struct: {}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStruct":{}}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_bad","expr":"TestAllTypes{single_struct: {1: 'uno'}}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"bad key type"}]}},"ast":"TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_struct: {'one': 1.0}}.single_struct","container":"cel.expr.conformance.proto3","value":{"mapValue":{"entries":[{"key":{"stringValue":"one"},"value":{"doubleValue":1}}]}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n \"one\"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{single_struct: {}}.single_struct","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto3_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.single_struct","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"}]},{"name":"value_null","tests":[{"original":{"name":"literal","expr":"Value{null_value: NullValue.NULL_VALUE}","container":"google.protobuf","value":{"nullValue":null}},"ast":"Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"Value{null_value: NullValue.NULL_VALUE}.null_value","disableCheck":true,"container":"google.protobuf","evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.null_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value.null_value~dyn","type":"dyn"},{"original":{"name":"literal_unset","expr":"google.protobuf.Value{}","value":{"nullValue":null}},"ast":"google.protobuf.Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":null}}}},"value":{"nullValue":null}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: null}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":null}}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_value","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: null}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":null}}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_value","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_number","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{number_value: 12.5}","value":{"doubleValue":12.5}},"ast":"google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{number_value: 12.5}.number_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.number_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value.number_value~dyn","type":"dyn"},{"original":{"name":"literal_zero","expr":"google.protobuf.Value{number_value: 0.0}","value":{"doubleValue":0}},"ast":"google.protobuf.Value{\n number_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n number_value:0~double\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":-26.375}}}},"value":{"doubleValue":-26.375}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: 7e23}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":7e+23}}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_value: 0.0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":0}}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: 7e23}.single_value","container":"cel.expr.conformance.proto2","value":{"doubleValue":7e+23}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_value: 0.0}.single_value","container":"cel.expr.conformance.proto2","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: 7e23}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":7e+23}}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_value: 0.0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":0}}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: 7e23}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":7e+23}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_value: 0.0}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_string","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{string_value: 'foo'}","value":{"stringValue":"foo"}},"ast":"google.protobuf.Value{\n string_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n string_value:\"foo\"~string\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{string_value: 'foo'}.string_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n string_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.string_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n string_value:\"foo\"~string\n}~dyn^google.protobuf.Value.string_value~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Value{string_value: ''}","value":{"stringValue":""}},"ast":"google.protobuf.Value{\n string_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n string_value:\"\"~string\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":"bar"}}}},"value":{"stringValue":"bar"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: 'baz'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":"baz"}}},"ast":"TestAllTypes{\n single_value:\"baz\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"baz\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_value: ''}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":""}}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: 'bletch'}.single_value","container":"cel.expr.conformance.proto2","value":{"stringValue":"bletch"}},"ast":"TestAllTypes{\n single_value:\"bletch\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"bletch\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_value: ''}.single_value","container":"cel.expr.conformance.proto2","value":{"stringValue":""}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: 'baz'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":"baz"}}},"ast":"TestAllTypes{\n single_value:\"baz\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"baz\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_value: ''}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":""}}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: 'bletch'}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"bletch"}},"ast":"TestAllTypes{\n single_value:\"bletch\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"bletch\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_value: ''}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":""}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_bool","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{bool_value: true}","value":{"boolValue":true}},"ast":"google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{bool_value: true}.bool_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.bool_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value.bool_value~dyn","type":"dyn"},{"original":{"name":"literal_false","expr":"google.protobuf.Value{bool_value: false}","value":{"boolValue":false}},"ast":"google.protobuf.Value{\n bool_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n bool_value:false~bool\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":true}}}},"value":{"boolValue":true}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":true}}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_false","expr":"TestAllTypes{single_value: false}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":false}}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: true}.single_value","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_false","expr":"TestAllTypes{single_value: false}.single_value","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":true}}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_false","expr":"TestAllTypes{single_value: false}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":false}}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: true}.single_value","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_false","expr":"TestAllTypes{single_value: false}.single_value","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_struct","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}","value":{"mapValue":{"entries":[{"key":{"stringValue":"a"},"value":{"doubleValue":1}},{"key":{"stringValue":"b"},"value":{"stringValue":"two"}}]}}},"ast":"google.protobuf.Value{\n struct_value:{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n struct_value:{\n \"a\"~string:1~double,\n \"b\"~string:\"two\"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}.struct_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n struct_value:{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.struct_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n struct_value:{\n \"a\"~string:1~double,\n \"b\"~string:\"two\"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value.struct_value~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Value{struct_value: {}}","value":{"mapValue":{}}},"ast":"google.protobuf.Value{\n struct_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n struct_value:{}~map(string, dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":{"x":null,"y":false}}}}},"value":{"mapValue":{"entries":[{"key":{"stringValue":"x"},"value":{"nullValue":null}},{"key":{"stringValue":"y"},"value":{"boolValue":false}}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_value:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_value: {}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":{}}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: {'i': true}}.single_value","container":"cel.expr.conformance.proto2","value":{"mapValue":{"entries":[{"key":{"stringValue":"i"},"value":{"boolValue":true}}]}}},"ast":"TestAllTypes{\n single_value:{\n \"i\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n \"i\"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{single_value: {}}.single_value","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_value:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_value: {}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":{}}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: {'i': true}}.single_value","container":"cel.expr.conformance.proto3","value":{"mapValue":{"entries":[{"key":{"stringValue":"i"},"value":{"boolValue":true}}]}}},"ast":"TestAllTypes{\n single_value:{\n \"i\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n \"i\"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{single_value: {}}.single_value","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_list","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{list_value: ['a', 3.0]}","value":{"listValue":{"values":[{"stringValue":"a"},{"doubleValue":3}]}}},"ast":"google.protobuf.Value{\n list_value:[\n \"a\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n list_value:[\n \"a\"~string,\n 3~double\n ]~list(dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{list_value: []}.list_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value.list_value~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Value{list_value: []}","value":{"listValue":{}}},"ast":"google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":[1,true,"hi"]}}}},"value":{"listValue":{"values":[{"doubleValue":1},{"boolValue":true},{"stringValue":"hi"}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: ['un', 1.0]}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":["un",1]}}},"ast":"TestAllTypes{\n single_value:[\n \"un\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n \"un\"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_value: []}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":[]}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: ['i', true]}.single_value","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"i"},{"boolValue":true}]}}},"ast":"TestAllTypes{\n single_value:[\n \"i\"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n \"i\"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{single_value: []}.single_value","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: ['un', 1.0]}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":["un",1]}}},"ast":"TestAllTypes{\n single_value:[\n \"un\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n \"un\"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_value: []}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":[]}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: ['i', true]}.single_value","container":"cel.expr.conformance.proto3","value":{"listValue":{"values":[{"stringValue":"i"},{"boolValue":true}]}}},"ast":"TestAllTypes{\n single_value:[\n \"i\"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n \"i\"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{single_value: []}.single_value","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"any","tests":[{"original":{"name":"literal","expr":"google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}},"ast":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\b\\x96\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\b\\x96\\x01\"~bytes\n}~any^google.protobuf.Any","type":"any"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}.type_url","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\b\\x96\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.type_url^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\b\\x96\\x01\"~bytes\n}~any^google.protobuf.Any.type_url~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Any{}","evalError":{"errors":[{"message":"conversion"}]}},"ast":"google.protobuf.Any{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Any{}~any^google.protobuf.Any","type":"any"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Any"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Any","value":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}}}},"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~any^x","type":"any"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":150}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":150}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"complex","tests":[{"original":{"name":"any_list_map","expr":"TestAllTypes{single_any: [{'almost': 'done'}]}.single_any","container":"cel.expr.conformance.proto3","value":{"listValue":{"values":[{"mapValue":{"entries":[{"key":{"stringValue":"almost"},"value":{"stringValue":"done"}}]}}]}}},"ast":"TestAllTypes{\n single_any:[\n {\n \"almost\"^#*expr.Constant_StringValue#:\"done\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:[\n {\n \"almost\"~string:\"done\"~string\n }~map(string, string)\n ]~list(map(string, string))\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]}]},{"name":"encoders_ext","suites":[{"name":"encode","tests":[{"original":{"name":"hello","expr":"base64.encode(b'hello')","value":{"stringValue":"aGVsbG8="}},"ast":"base64^#*expr.Expr_IdentExpr#.encode(\n b\"hello\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.encode(\n b\"hello\"~bytes\n)~string^base64_encode_bytes","type":"string"}]},{"name":"decode","tests":[{"original":{"name":"hello","expr":"base64.decode('aGVsbG8=')","value":{"bytesValue":"aGVsbG8="}},"ast":"base64^#*expr.Expr_IdentExpr#.decode(\n \"aGVsbG8=\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.decode(\n \"aGVsbG8=\"~string\n)~bytes^base64_decode_string","type":"bytes"},{"original":{"name":"hello_without_padding","expr":"base64.decode('aGVsbG8')","value":{"bytesValue":"aGVsbG8="}},"ast":"base64^#*expr.Expr_IdentExpr#.decode(\n \"aGVsbG8\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.decode(\n \"aGVsbG8\"~string\n)~bytes^base64_decode_string","type":"bytes"}]},{"name":"round_trip","tests":[{"original":{"name":"hello","expr":"base64.decode(base64.encode(b'Hello World!'))","value":{"bytesValue":"SGVsbG8gV29ybGQh"}},"ast":"base64^#*expr.Expr_IdentExpr#.decode(\n base64^#*expr.Expr_IdentExpr#.encode(\n b\"Hello World!\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.decode(\n base64.encode(\n b\"Hello World!\"~bytes\n )~string^base64_encode_bytes\n)~bytes^base64_decode_string","type":"bytes"}]}]},{"name":"enums","suites":[{"name":"legacy_proto2","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto2","value":{"int64Value":"2"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto2","value":{"int64Value":"1"}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison","expr":"GlobalEnum.GAR == 1","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"arithmetic","expr":"TestAllTypes.NestedEnum.BAR + 3","container":"cel.expr.conformance.proto2","value":{"int64Value":"4"}},"ast":"_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64","type":"int"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto2","value":{"typeValue":"int"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto2","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: 1}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_big","expr":"TestAllTypes{standalone_enum: 5000000000}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_neg","expr":"TestAllTypes{standalone_enum: -7000000000}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"access_repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"assign_repeated_enum","expr":"TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","repeatedNestedEnum":["FOO","BAR"]}}},"ast":"TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"list_enum_as_list_int","expr":"0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"enum_as_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list","type":"bool"}]},{"name":"legacy_proto3","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto3","value":{"int64Value":"2"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto3","value":{"int64Value":"1"}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison","expr":"GlobalEnum.GAR == 1","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"arithmetic","expr":"TestAllTypes.NestedEnum.BAR + 3","container":"cel.expr.conformance.proto3","value":{"int64Value":"4"}},"ast":"_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64","type":"int"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto3","value":{"typeValue":"int"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto3","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"select","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}}},"value":{"int64Value":"2"}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_big","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":108}}}},"value":{"int64Value":"108"}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_neg","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-3}}}},"value":{"int64Value":"-3"}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: 1}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_big","expr":"TestAllTypes{standalone_enum: 99}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":99}}},"ast":"TestAllTypes{\n standalone_enum:99^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:99~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_neg","expr":"TestAllTypes{standalone_enum: -1}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-1}}},"ast":"TestAllTypes{\n standalone_enum:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_big","expr":"TestAllTypes{standalone_enum: 5000000000}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_neg","expr":"TestAllTypes{standalone_enum: -7000000000}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"access_repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"assign_repeated_enum","expr":"TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","repeatedNestedEnum":["FOO","BAR"]}}},"ast":"TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"list_enum_as_list_int","expr":"0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"enum_as_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list","type":"bool"}]},{"name":"strong_proto2","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum","value":2}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":1}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum"}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison_true","expr":"GlobalEnum.GAR == GlobalEnum.GAR","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR\n)~bool^equals","type":"bool"},{"original":{"name":"comparison_false","expr":"GlobalEnum.GAR == GlobalEnum.GAZ","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~bool^equals","type":"bool"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto2","value":{"typeValue":"cel.expr.conformance.proto2.GlobalEnum"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto2","value":{"typeValue":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"typeValue":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^"},{"original":{"name":"convert_symbol_to_int","expr":"int(GlobalEnum.GAZ)","container":"cel.expr.conformance.proto2","value":{"int64Value":"2"}},"ast":"int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~int^int64_to_int64","type":"int"},{"original":{"name":"convert_unnamed_to_int","description":"Disable check - missing way to declare enums.","expr":"int(x)","disableCheck":true,"bindings":{"x":{"value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum","value":444}}}},"value":{"int64Value":"444"}},"ast":"int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^"},{"original":{"name":"convert_int_inrange","expr":"TestAllTypes.NestedEnum(2)","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(2)\n | .......................^"},{"original":{"name":"convert_int_big","expr":"TestAllTypes.NestedEnum(20000)","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":20000}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(20000)\n | .......................^"},{"original":{"name":"convert_int_neg","expr":"GlobalEnum(-33)","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum","value":-33}}},"ast":"GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto2')\n | GlobalEnum(-33)\n | ..........^"},{"original":{"name":"convert_int_too_big","expr":"TestAllTypes.NestedEnum(5000000000)","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^"},{"original":{"name":"convert_int_too_neg","expr":"TestAllTypes.NestedEnum(-7000000000)","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^"},{"original":{"name":"convert_string","expr":"TestAllTypes.NestedEnum('BAZ')","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BAZ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^"},{"original":{"name":"convert_string_bad","expr":"TestAllTypes.NestedEnum('BLETCH')","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"invalid"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BLETCH\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^"}]},{"name":"strong_proto3","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum","value":2}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":1}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum"}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison_true","expr":"GlobalEnum.GAR == GlobalEnum.GAR","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR\n)~bool^equals","type":"bool"},{"original":{"name":"comparison_false","expr":"GlobalEnum.GAR == GlobalEnum.GAZ","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~bool^equals","type":"bool"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto3","value":{"typeValue":"cel.expr.conformance.proto3.GlobalEnum"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto3","value":{"typeValue":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"select","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}}},"value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":2}}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_big","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":108}}}},"value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":108}}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_neg","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-3}}}},"value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":-3}}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"typeValue":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^"},{"original":{"name":"assign_standalone_int_big","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":99}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 99^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}\n | .....................................................^"},{"original":{"name":"assign_standalone_int_neg","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-1}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}\n | .....................................................^"},{"original":{"name":"convert_symbol_to_int","expr":"int(GlobalEnum.GAZ)","container":"cel.expr.conformance.proto3","value":{"int64Value":"2"}},"ast":"int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~int^int64_to_int64","type":"int"},{"original":{"name":"convert_unnamed_to_int","description":"Disable check - missing way to declare enums.","expr":"int(x)","disableCheck":true,"bindings":{"x":{"value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum","value":444}}}},"value":{"int64Value":"444"}},"ast":"int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^"},{"original":{"name":"convert_unnamed_to_int_select","expr":"int(x.standalone_enum)","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-987}}}},"value":{"int64Value":"-987"}},"ast":"int(\n x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int\n)~int^int64_to_int64","type":"int"},{"original":{"name":"convert_int_inrange","expr":"TestAllTypes.NestedEnum(2)","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(2)\n | .......................^"},{"original":{"name":"convert_int_big","expr":"TestAllTypes.NestedEnum(20000)","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":20000}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(20000)\n | .......................^"},{"original":{"name":"convert_int_neg","expr":"GlobalEnum(-33)","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum","value":-33}}},"ast":"GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto3')\n | GlobalEnum(-33)\n | ..........^"},{"original":{"name":"convert_int_too_big","expr":"TestAllTypes.NestedEnum(5000000000)","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^"},{"original":{"name":"convert_int_too_neg","expr":"TestAllTypes.NestedEnum(-7000000000)","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^"},{"original":{"name":"convert_string","expr":"TestAllTypes.NestedEnum('BAZ')","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BAZ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^"},{"original":{"name":"convert_string_bad","expr":"TestAllTypes.NestedEnum('BLETCH')","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"invalid"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BLETCH\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^"}]}]},{"name":"fields","suites":[{"name":"map_fields","tests":[{"original":{"name":"map_key_int64","expr":"{0:1,2:2,5:true}[5]","value":{"boolValue":true}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:true~bool\n }~map(int, dyn),\n 5~int\n)~dyn^index_map","type":"dyn"},{"original":{"name":"map_key_uint64","expr":"{0u:1u,2u:'happy',5u:3u}[2u]","value":{"stringValue":"happy"}},"ast":"_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:\"happy\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:\"happy\"~string,\n 5u~uint:3u~uint\n }~map(uint, dyn),\n 2u~uint\n)~dyn^index_map","type":"dyn"},{"original":{"name":"map_key_string","expr":"{'name':100u}['name']","value":{"uint64Value":"100"}},"ast":"_[_](\n {\n \"name\"^#*expr.Constant_StringValue#:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"name\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"name\"~string:100u~uint\n }~map(string, uint),\n \"name\"~string\n)~uint^index_map","type":"uint"},{"original":{"name":"map_key_bool","expr":"{true:5}[true]","value":{"int64Value":"5"}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:5~int\n }~map(bool, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_key_mixed_type","expr":"{true:1,2:2,5u:3}[true]","value":{"int64Value":"1"}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:1~int,\n 2~int:2~int,\n 5u~uint:3~int\n }~map(dyn, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_key_mixed_numbers_double_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[3.0]","value":{"doubleValue":3}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3~double\n)~double^index_map","type":"double"},{"original":{"name":"map_key_mixed_numbers_lossy_double_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[3.1]","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3.1~double\n)~double^index_map","type":"double"},{"original":{"name":"map_key_mixed_numbers_uint_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[2u]","value":{"doubleValue":2}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 2u~uint\n)~double^index_map","type":"double"},{"original":{"name":"map_key_mixed_numbers_int_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[1]","value":{"doubleValue":1}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 1~int\n)~double^index_map","type":"double"},{"original":{"name":"map_field_access","expr":"x.name","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"INT64"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"name"},"value":{"int64Value":"1024"}}]}}}},"value":{"int64Value":"1024"}},"ast":"x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#","checkedAst":"x~map(string, int)^x.name~int","type":"int"},{"original":{"name":"map_no_such_key","expr":"{0:1,2:2,5:3}[1]","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n)~int^index_map","type":"int"},{"original":{"name":"map_no_such_key_or_false","expr":"dyn({0:1,2:2,5:3}[1]) || false","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_no_such_key_or_true","expr":"dyn({0:1,2:2,5:3}[1]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_no_such_key_and_false","expr":"dyn({0:1,2:2,5:3}[1]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_no_such_key_and_true","expr":"dyn({0:1,2:2,5:3}[1]) \u0026\u0026 true","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_bad_key_type","expr":"{0:1,2:2,5:3}[dyn(b'')]","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n)~int^index_map","type":"int"},{"original":{"name":"map_bad_key_type_or_false","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) || false","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_bad_key_type_or_true","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_bad_key_type_and_false","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_bad_key_type_and_true","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 true","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_field_select_no_such_key","expr":"x.name","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"evalError":{"errors":[{"message":"no such key: 'name'"}]}},"ast":"x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#","checkedAst":"x~map(string, string)^x.name~string","type":"string"},{"original":{"name":"map_field_select_no_such_key_or_false","expr":"dyn(x.name) || false","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"evalError":{"errors":[{"message":"no such key: 'name'"}]}},"ast":"_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_field_select_no_such_key_or_true","expr":"dyn(x.name) || true","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"value":{"boolValue":true}},"ast":"_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_field_select_no_such_key_and_false","expr":"dyn(x.name) \u0026\u0026 false","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_field_select_no_such_key_and_true","expr":"dyn(x.name) \u0026\u0026 true","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"evalError":{"errors":[{"message":"no such key: 'name'"}]}},"ast":"_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_value_null","expr":"{true:null}[true]","value":{"nullValue":null}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:null~null\n }~map(bool, null),\n true~bool\n)~null^index_map","type":"null"},{"original":{"name":"map_value_bool","expr":"{27:false}[27]","value":{"boolValue":false}},"ast":"_[_](\n {\n 27^#*expr.Constant_Int64Value#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 27^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 27~int:false~bool\n }~map(int, bool),\n 27~int\n)~bool^index_map","type":"bool"},{"original":{"name":"map_value_string","expr":"{'n':'x'}['n']","value":{"stringValue":"x"}},"ast":"_[_](\n {\n \"n\"^#*expr.Constant_StringValue#:\"x\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"n\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"n\"~string:\"x\"~string\n }~map(string, string),\n \"n\"~string\n)~string^index_map","type":"string"},{"original":{"name":"map_value_float","expr":"{3:15.15}[3]","value":{"doubleValue":15.15}},"ast":"_[_](\n {\n 3^#*expr.Constant_Int64Value#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 3~int:15.15~double\n }~map(int, double),\n 3~int\n)~double^index_map","type":"double"},{"original":{"name":"map_value_uint64","expr":"{0u:1u,2u:2u,5u:3u}[0u]","value":{"uint64Value":"1"}},"ast":"_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:2u~uint,\n 5u~uint:3u~uint\n }~map(uint, uint),\n 0u~uint\n)~uint^index_map","type":"uint"},{"original":{"name":"map_value_int64","expr":"{true:1,false:2}[true]","value":{"int64Value":"1"}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:1~int,\n false~bool:2~int\n }~map(bool, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_value_bytes","expr":"{0:b''}[0]","value":{"bytesValue":""}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:b\"\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:b\"\"~bytes\n }~map(int, bytes),\n 0~int\n)~bytes^index_map","type":"bytes"},{"original":{"name":"map_value_list","expr":"{0u:[1]}[0u]","value":{"listValue":{"values":[{"int64Value":"1"}]}}},"ast":"_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0u~uint:[\n 1~int\n ]~list(int)\n }~map(uint, list(int)),\n 0u~uint\n)~list(int)^index_map","type":"list(int)"},{"original":{"name":"map_value_map","expr":"{'map': {'k': 'v'}}['map']","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}}]}}},"ast":"_[_](\n {\n \"map\"^#*expr.Constant_StringValue#:{\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"map\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"map\"~string:{\n \"k\"~string:\"v\"~string\n }~map(string, string)\n }~map(string, map(string, string)),\n \"map\"~string\n)~map(string, string)^index_map","type":"map(string, string)"},{"original":{"name":"map_value_mix_type","expr":"{'map': {'k': 'v'}, 'list': [1]}['map']","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}}]}}},"ast":"_[_](\n {\n \"map\"^#*expr.Constant_StringValue#:{\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"list\"^#*expr.Constant_StringValue#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"map\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"map\"~string:{\n \"k\"~string:\"v\"~string\n }~map(string, string),\n \"list\"~string:[\n 1~int\n ]~list(int)\n }~map(string, dyn),\n \"map\"~string\n)~dyn^index_map","type":"dyn"}]},{"name":"map_has","tests":[{"original":{"name":"has","expr":"has({'a': 1, 'b': 2}.a)","value":{"boolValue":true}},"ast":"{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"a\"~string:1~int,\n \"b\"~string:2~int\n}~map(string, int).a~test-only~~bool","type":"bool"},{"original":{"name":"has_not","expr":"has({'a': 1, 'b': 2}.c)","value":{"boolValue":false}},"ast":"{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.c~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"a\"~string:1~int,\n \"b\"~string:2~int\n}~map(string, int).c~test-only~~bool","type":"bool"},{"original":{"name":"has_empty","expr":"has({}.a)","value":{"boolValue":false}},"ast":"{}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{}~map(dyn, dyn).a~test-only~~bool","type":"bool"}]},{"name":"quoted_map_fields","tests":[{"original":{"name":"field_access_slash","expr":"{'/api/v1': true, '/api/v2': false}.`/api/v1`","value":{"boolValue":true}},"error":"ERROR: field_access_slash:1:37: unsupported syntax: '`'\n | {'/api/v1': true, '/api/v2': false}.`/api/v1`\n | ....................................^"},{"original":{"name":"field_access_dash","expr":"{'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'","value":{"boolValue":true}},"error":"ERROR: field_access_dash:1:61: unsupported syntax: '`'\n | {'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'\n | ............................................................^"},{"original":{"name":"field_access_dot","expr":"{'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`","value":{"int64Value":"32"}},"error":"ERROR: field_access_dot:1:34: unsupported syntax: '`'\n | {'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`\n | .................................^"},{"original":{"name":"has_field_slash","expr":"has({'/api/v1': true, '/api/v2': false}.`/api/v3`)","value":{"boolValue":false}},"error":"ERROR: has_field_slash:1:41: unsupported syntax: '`'\n | has({'/api/v1': true, '/api/v2': false}.`/api/v3`)\n | ........................................^"},{"original":{"name":"has_field_dash","expr":"has({'content-type': 'application/json', 'content-length': 145}.`content-type`)","value":{"boolValue":true}},"error":"ERROR: has_field_dash:1:65: unsupported syntax: '`'\n | has({'content-type': 'application/json', 'content-length': 145}.`content-type`)\n | ................................................................^"},{"original":{"name":"has_field_dot","expr":"has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)","value":{"boolValue":true}},"error":"ERROR: has_field_dot:1:38: unsupported syntax: '`'\n | has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)\n | .....................................^"}]},{"name":"qualified_identifier_resolution","tests":[{"original":{"name":"qualified_ident","expr":"a.b.c","typeEnv":[{"name":"a.b.c","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"a.b.c":{"value":{"stringValue":"yeah"}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b.c~string^a.b.c","type":"string"},{"original":{"name":"map_field_select","expr":"a.b.c","typeEnv":[{"name":"a.b","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"yeah"}}]}}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b~map(string, string)^a.b.c~string","type":"string"},{"original":{"name":"qualified_identifier_resolution_unchecked","description":"namespace resolution should try to find the longest prefix for the evaluator.","expr":"a.b.c","disableCheck":true,"typeEnv":[{"name":"a.b.c","ident":{"type":{"primitive":"STRING"}}},{"name":"a.b","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"oops"}}]}}},"a.b.c":{"value":{"stringValue":"yeah"}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b.c~string^a.b.c","type":"string"},{"original":{"name":"list_field_select_unsupported","expr":"a.b.pancakes","disableCheck":true,"typeEnv":[{"name":"a.b","ident":{"type":{"listType":{"elemType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"listValue":{"values":[{"stringValue":"pancakes"}]}}}},"evalError":{"errors":[{"message":"type 'list_type:\u003celem_type:\u003cprimitive:STRING \u003e \u003e ' does not support field selection"}]}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.pancakes^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:4: type 'list(string)' does not support field selection\n | a.b.pancakes\n | ...^"},{"original":{"name":"int64_field_select_unsupported","expr":"a.pancakes","disableCheck":true,"typeEnv":[{"name":"a","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"a":{"value":{"int64Value":"15"}}},"evalError":{"errors":[{"message":"type 'int64_type' does not support field selection"}]}},"ast":"a^#*expr.Expr_IdentExpr#.pancakes^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:2: type 'int' does not support field selection\n | a.pancakes\n | .^"},{"original":{"name":"ident_with_longest_prefix_check","description":"namespace resolution should try to find the longest prefix for the checker.","expr":"a.b.c","typeEnv":[{"name":"a.b.c","ident":{"type":{"primitive":"STRING"}}},{"name":"a.b","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"oops"}}]}}},"a.b.c":{"value":{"stringValue":"yeah"}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b.c~string^a.b.c","type":"string"},{"original":{"name":"map_key_float","description":"map should not support float as the key.","expr":"{3.3:15.15, 1.0: 5}[1.0]","disableCheck":true,"evalError":{"errors":[{"message":"unsupported key type"}]}},"ast":"_[_](\n {\n 3.3^#*expr.Constant_DoubleValue#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_DoubleValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 3.3~double:15.15~double,\n 1~double:5~int\n }~map(double, dyn),\n 1~double\n)~dyn^index_map","type":"dyn"},{"original":{"name":"map_key_null","description":"map should not support null as the key.","expr":"{null:false}[null]","disableCheck":true,"evalError":{"errors":[{"message":"unsupported key type"}]}},"ast":"_[_](\n {\n null^#*expr.Constant_NullValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n null~null:false~bool\n }~map(null, bool),\n null~null\n)~bool^index_map","type":"bool"},{"original":{"name":"map_value_repeat_key","description":"map should not support repeated key.","expr":"{true:1,false:2,true:3}[true]","evalError":{"errors":[{"message":"Failed with repeated key"}]}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:1~int,\n false~bool:2~int,\n true~bool:3~int\n }~map(bool, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_value_repeat_key_heterogeneous","description":"map should not support repeated key.","expr":"{0: 1, 0u: 2}[0.0]","evalError":{"errors":[{"message":"Failed with repeated key"}]}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 0u^#*expr.Constant_Uint64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 0u~uint:2~int\n }~map(dyn, int),\n 0~double\n)~int^index_map","type":"int"}]},{"name":"in","tests":[{"original":{"name":"empty","expr":"7 in {}","value":{"boolValue":false}},"ast":"@in(\n 7^#*expr.Constant_Int64Value#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 7~int,\n {}~map(int, dyn)\n)~bool^in_map","type":"bool"},{"original":{"name":"singleton","expr":"true in {true: 1}","value":{"boolValue":true}},"ast":"@in(\n true^#*expr.Constant_BoolValue#,\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n true~bool,\n {\n true~bool:1~int\n }~map(bool, int)\n)~bool^in_map","type":"bool"},{"original":{"name":"present","expr":"'George' in {'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}","value":{"boolValue":true}},"ast":"@in(\n \"George\"^#*expr.Constant_StringValue#,\n {\n \"John\"^#*expr.Constant_StringValue#:\"smart\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Paul\"^#*expr.Constant_StringValue#:\"cute\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"George\"^#*expr.Constant_StringValue#:\"quiet\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Ringo\"^#*expr.Constant_StringValue#:\"funny\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"George\"~string,\n {\n \"John\"~string:\"smart\"~string,\n \"Paul\"~string:\"cute\"~string,\n \"George\"~string:\"quiet\"~string,\n \"Ringo\"~string:\"funny\"~string\n }~map(string, string)\n)~bool^in_map","type":"bool"},{"original":{"name":"absent","expr":"'spider' in {'ant': 6, 'fly': 6, 'centipede': 100}","value":{"boolValue":false}},"ast":"@in(\n \"spider\"^#*expr.Constant_StringValue#,\n {\n \"ant\"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"fly\"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"centipede\"^#*expr.Constant_StringValue#:100^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"spider\"~string,\n {\n \"ant\"~string:6~int,\n \"fly\"~string:6~int,\n \"centipede\"~string:100~int\n }~map(string, int)\n)~bool^in_map","type":"bool"},{"original":{"name":"mixed_numbers_and_keys_present","expr":"3.0 in {1: 1, 2: 2, 3u: 3} \u0026\u0026 2u in {1u: 1, 2: 2} \u0026\u0026 1 in {1u: 1, 2: 2}","value":{"boolValue":true}},"ast":"_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2u^#*expr.Constant_Uint64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n )~bool^in_map,\n @in(\n 2u~uint,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n )~bool^logical_and,\n @in(\n 1~int,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n)~bool^logical_and","type":"bool"},{"original":{"name":"mixed_numbers_and_keys_absent","expr":"3.1 in {1: 1, 2: 2, 3u: 3}","value":{"boolValue":false}},"ast":"@in(\n 3.1^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 3.1~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n)~bool^in_map","type":"bool"}]}]},{"name":"fp_math","suites":[{"name":"fp_math","tests":[{"original":{"name":"add_positive_positive","expr":"4.25 + 15.25","value":{"doubleValue":19.5}},"ast":"_+_(\n 4.25^#*expr.Constant_DoubleValue#,\n 15.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 4.25~double,\n 15.25~double\n)~double^add_double","type":"double"},{"original":{"name":"add_positive_negative","expr":"17.75 + (-7.75)","value":{"doubleValue":10}},"ast":"_+_(\n 17.75^#*expr.Constant_DoubleValue#,\n -7.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 17.75~double,\n -7.75~double\n)~double^add_double","type":"double"},{"original":{"name":"add_negative_negative","expr":"-4.125 + (-2.125)","value":{"doubleValue":-6.25}},"ast":"_+_(\n -4.125^#*expr.Constant_DoubleValue#,\n -2.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n -4.125~double,\n -2.125~double\n)~double^add_double","type":"double"},{"original":{"name":"sub_positive_positive","expr":"42.0 - 12.0","value":{"doubleValue":30}},"ast":"_-_(\n 42^#*expr.Constant_DoubleValue#,\n 12^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42~double,\n 12~double\n)~double^subtract_double","type":"double"},{"original":{"name":"sub_positive_negative","expr":"42.875 - (-22.0)","value":{"doubleValue":64.875}},"ast":"_-_(\n 42.875^#*expr.Constant_DoubleValue#,\n -22^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42.875~double,\n -22~double\n)~double^subtract_double","type":"double"},{"original":{"name":"sub_negative_negative","expr":"-4.875 - (-0.125)","value":{"doubleValue":-4.75}},"ast":"_-_(\n -4.875^#*expr.Constant_DoubleValue#,\n -0.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n -4.875~double,\n -0.125~double\n)~double^subtract_double","type":"double"},{"original":{"name":"multiply_positive_positive","expr":"42.5 * 0.2","value":{"doubleValue":8.5}},"ast":"_*_(\n 42.5^#*expr.Constant_DoubleValue#,\n 0.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 42.5~double,\n 0.2~double\n)~double^multiply_double","type":"double"},{"original":{"name":"multiply_positive_negative","expr":"40.75 * (-2.25)","value":{"doubleValue":-91.6875}},"ast":"_*_(\n 40.75^#*expr.Constant_DoubleValue#,\n -2.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 40.75~double,\n -2.25~double\n)~double^multiply_double","type":"double"},{"original":{"name":"multiply_negative_negative","expr":"-3.0 * (-2.5)","value":{"doubleValue":7.5}},"ast":"_*_(\n -3^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -3~double,\n -2.5~double\n)~double^multiply_double","type":"double"},{"original":{"name":"divide_positive_positive","expr":"0.0625 / 0.002","value":{"doubleValue":31.25}},"ast":"_/_(\n 0.0625^#*expr.Constant_DoubleValue#,\n 0.002^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 0.0625~double,\n 0.002~double\n)~double^divide_double","type":"double"},{"original":{"name":"divide_positive_negative","expr":"-2.0 / 2.0","value":{"doubleValue":-1}},"ast":"_/_(\n -2^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -2~double,\n 2~double\n)~double^divide_double","type":"double"},{"original":{"name":"divide_negative_negative","expr":"-8.875 / (-0.0625)","value":{"doubleValue":142}},"ast":"_/_(\n -8.875^#*expr.Constant_DoubleValue#,\n -0.0625^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -8.875~double,\n -0.0625~double\n)~double^divide_double","type":"double"},{"original":{"name":"mod_not_support","expr":"47.5 % 5.5","disableCheck":true,"evalError":{"errors":[{"message":"found no matching overload for '_%_' applied to '(double, double)'"}]}},"ast":"_%_(\n 47.5^#*expr.Constant_DoubleValue#,\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:6: found no matching overload for '_%_' applied to '(double, double)'\n | 47.5 % 5.5\n | .....^"},{"original":{"name":"negative","expr":"-(4.5)","value":{"doubleValue":-4.5}},"ast":"-_(\n 4.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 4.5~double\n)~double^negate_double","type":"double"},{"original":{"name":"double_negative","expr":"-(-1.25)","value":{"doubleValue":1.25}},"ast":"-_(\n -1.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -1.25~double\n)~double^negate_double","type":"double"},{"original":{"name":"negative_zero","expr":"-(0.0)","value":{"doubleValue":0}},"ast":"-_(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 0~double\n)~double^negate_double","type":"double"},{"original":{"name":"divide_zero","expr":"15.75 / 0.0","value":{"doubleValue":"Infinity"}},"ast":"_/_(\n 15.75^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 15.75~double,\n 0~double\n)~double^divide_double","type":"double"},{"original":{"name":"multiply_zero","expr":"15.36 * 0.0","value":{"doubleValue":0}},"ast":"_*_(\n 15.36^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 15.36~double,\n 0~double\n)~double^multiply_double","type":"double"},{"original":{"name":"add_left_identity","expr":"0.0 + 1.75","value":{"doubleValue":1.75}},"ast":"_+_(\n 0^#*expr.Constant_DoubleValue#,\n 1.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 0~double,\n 1.75~double\n)~double^add_double","type":"double"},{"original":{"name":"add_right_identity","expr":" 2.5 + 0.0","value":{"doubleValue":2.5}},"ast":"_+_(\n 2.5^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 2.5~double,\n 0~double\n)~double^add_double","type":"double"},{"original":{"name":"add_commutative","expr":"7.5 + 1.5 == 1.5 + 7.5","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 7.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 7.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 7.5~double,\n 1.5~double\n )~double^add_double,\n _+_(\n 1.5~double,\n 7.5~double\n )~double^add_double\n)~bool^equals","type":"bool"},{"original":{"name":"add_associative","expr":"5.625 + (15.75 + 2.0) == (5.625 + 15.75) + 2.0","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n _+_(\n 15.75^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n 15.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 5.625~double,\n _+_(\n 15.75~double,\n 2~double\n )~double^add_double\n )~double^add_double,\n _+_(\n _+_(\n 5.625~double,\n 15.75~double\n )~double^add_double,\n 2~double\n )~double^add_double\n)~bool^equals","type":"bool"},{"original":{"name":"mul_left_identity","expr":"1.0 * 45.25","value":{"doubleValue":45.25}},"ast":"_*_(\n 1^#*expr.Constant_DoubleValue#,\n 45.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 1~double,\n 45.25~double\n)~double^multiply_double","type":"double"},{"original":{"name":"mul_right_identity","expr":"-25.25 * 1.0","value":{"doubleValue":-25.25}},"ast":"_*_(\n -25.25^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -25.25~double,\n 1~double\n)~double^multiply_double","type":"double"},{"original":{"name":"mul_commutative","expr":"1.5 * 25.875 == 25.875 * 1.5","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 25.875^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25.875^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 1.5~double,\n 25.875~double\n )~double^multiply_double,\n _*_(\n 25.875~double,\n 1.5~double\n )~double^multiply_double\n)~bool^equals","type":"bool"},{"original":{"name":"mul_associative","expr":"1.5 * (23.625 * 0.75) == (1.5 * 23.625) * 0.75","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n _*_(\n 23.625^#*expr.Constant_DoubleValue#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 23.625^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 1.5~double,\n _*_(\n 23.625~double,\n 0.75~double\n )~double^multiply_double\n )~double^multiply_double,\n _*_(\n _*_(\n 1.5~double,\n 23.625~double\n )~double^multiply_double,\n 0.75~double\n )~double^multiply_double\n)~bool^equals","type":"bool"},{"original":{"name":"add_mul_distribute","expr":"5.75 * (1.5 + 2.5) == 5.75 * 1.5 + 5.75 * 2.5","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 5.75~double,\n _+_(\n 1.5~double,\n 2.5~double\n )~double^add_double\n )~double^multiply_double,\n _+_(\n _*_(\n 5.75~double,\n 1.5~double\n )~double^multiply_double,\n _*_(\n 5.75~double,\n 2.5~double\n )~double^multiply_double\n )~double^add_double\n)~bool^equals","type":"bool"},{"original":{"name":"fp_overflow_positive","description":"DBL_MAX(2^1023) times two","expr":"2.0 * 8.988466e+307 ","value":{"doubleValue":"Infinity"}},"ast":"_*_(\n 2^#*expr.Constant_DoubleValue#,\n 8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 2~double,\n 8.988466e+307~double\n)~double^multiply_double","type":"double"},{"original":{"name":"fp_overflow_negative","description":"-DBL_MAX(-2^1023) times two","expr":"2.0 * -8.988466e+307 ","value":{"doubleValue":"-Infinity"}},"ast":"_*_(\n 2^#*expr.Constant_DoubleValue#,\n -8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 2~double,\n -8.988466e+307~double\n)~double^multiply_double","type":"double"},{"original":{"name":"fp_underflow","description":"DBL_MIN(2^-1074) divided by two","expr":"1e-324 / 2.0","value":{"doubleValue":0}},"ast":"_/_(\n 0^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 0~double,\n 2~double\n)~double^divide_double","type":"double"}]}]},{"name":"integer_math","suites":[{"name":"int64_math","tests":[{"original":{"name":"add_positive_positive","expr":"40 + 2","value":{"int64Value":"42"}},"ast":"_+_(\n 40^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 40~int,\n 2~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_positive_negative","expr":"42 + (-7)","value":{"int64Value":"35"}},"ast":"_+_(\n 42^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 42~int,\n -7~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_negative_negative","expr":"-4 + (-2)","value":{"int64Value":"-6"}},"ast":"_+_(\n -4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n -4~int,\n -2~int\n)~int^add_int64","type":"int"},{"original":{"name":"sub_positive_positive","expr":"42 - 12","value":{"int64Value":"30"}},"ast":"_-_(\n 42^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42~int,\n 12~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"sub_positive_negative","expr":"42 - (-22)","value":{"int64Value":"64"}},"ast":"_-_(\n 42^#*expr.Constant_Int64Value#,\n -22^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42~int,\n -22~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"sub_negative_negative","expr":"-42 - (-12)","value":{"int64Value":"-30"}},"ast":"_-_(\n -42^#*expr.Constant_Int64Value#,\n -12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n -42~int,\n -12~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"multiply_positive_positive","expr":"42 * 2","value":{"int64Value":"84"}},"ast":"_*_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 42~int,\n 2~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"multiply_positive_negative","expr":"40 * (-2)","value":{"int64Value":"-80"}},"ast":"_*_(\n 40^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 40~int,\n -2~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"multiply_negative_negative","expr":"-30 * (-2)","value":{"int64Value":"60"}},"ast":"_*_(\n -30^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -30~int,\n -2~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"divide_positive_positive","expr":"42 / 2","value":{"int64Value":"21"}},"ast":"_/_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 42~int,\n 2~int\n)~int^divide_int64","type":"int"},{"original":{"name":"divide_positive_negative","expr":"-20 / 2","value":{"int64Value":"-10"}},"ast":"_/_(\n -20^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -20~int,\n 2~int\n)~int^divide_int64","type":"int"},{"original":{"name":"divide_negative_negative","expr":"-80 / (-2)","value":{"int64Value":"40"}},"ast":"_/_(\n -80^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -80~int,\n -2~int\n)~int^divide_int64","type":"int"},{"original":{"name":"mod_positive_positive","expr":"47 % 5","value":{"int64Value":"2"}},"ast":"_%_(\n 47^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 47~int,\n 5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"mod_positive_negative","expr":"43 % (-5)","value":{"int64Value":"3"}},"ast":"_%_(\n 43^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 43~int,\n -5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"mod_negative_negative","expr":"-42 % (-5)","value":{"int64Value":"-2"}},"ast":"_%_(\n -42^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n -42~int,\n -5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"mod_negative_positive","expr":"-3 % 5","value":{"int64Value":"-3"}},"ast":"_%_(\n -3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n -3~int,\n 5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"unary_minus_pos","expr":"-(42)","value":{"int64Value":"-42"}},"ast":"-_(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 42~int\n)~int^negate_int64","type":"int"},{"original":{"name":"unary_minus_neg","expr":"-(-42)","value":{"int64Value":"42"}},"ast":"-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -42~int\n)~int^negate_int64","type":"int"},{"original":{"name":"unary_minus_no_overload","expr":"-(42u)","disableCheck":true,"evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"-_(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(42u)\n | ^"},{"original":{"name":"unary_minus_not_bool","expr":"-false","disableCheck":true,"evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"-_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(bool)'\n | -false\n | ^"},{"original":{"name":"mod_zero","expr":"34 % 0","evalError":{"errors":[{"message":"modulus by zero"}]}},"ast":"_%_(\n 34^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 34~int,\n 0~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"negative_zero","expr":"-(0)","value":{"int64Value":"0"}},"ast":"-_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 0~int\n)~int^negate_int64","type":"int"},{"original":{"name":"double_negative","expr":"-(-42)","value":{"int64Value":"42"}},"ast":"-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -42~int\n)~int^negate_int64","type":"int"},{"original":{"name":"divide_zero","expr":"15 / 0","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"_/_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 15~int,\n 0~int\n)~int^divide_int64","type":"int"},{"original":{"name":"multiply_zero","expr":"15 * 0","value":{"int64Value":"0"}},"ast":"_*_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 15~int,\n 0~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"add_left_identity","expr":"0 + 17","value":{"int64Value":"17"}},"ast":"_+_(\n 0^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 0~int,\n 17~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_right_identity","expr":" 29 + 0","value":{"int64Value":"29"}},"ast":"_+_(\n 29^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 29~int,\n 0~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_commutative","expr":"75 + 15 == 15 + 75","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 75^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 75~int,\n 15~int\n )~int^add_int64,\n _+_(\n 15~int,\n 75~int\n )~int^add_int64\n)~bool^equals","type":"bool"},{"original":{"name":"add_associative","expr":"5 + (15 + 20) == (5 + 15) + 20","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 5~int,\n _+_(\n 15~int,\n 20~int\n )~int^add_int64\n )~int^add_int64,\n _+_(\n _+_(\n 5~int,\n 15~int\n )~int^add_int64,\n 20~int\n )~int^add_int64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_left_identity","expr":"1 * 45","value":{"int64Value":"45"}},"ast":"_*_(\n 1^#*expr.Constant_Int64Value#,\n 45^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 1~int,\n 45~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"mul_right_identity","expr":"-25 * 1","value":{"int64Value":"-25"}},"ast":"_*_(\n -25^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -25~int,\n 1~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"mul_commutative","expr":"15 * 25 == 25 * 15","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15~int,\n 25~int\n )~int^multiply_int64,\n _*_(\n 25~int,\n 15~int\n )~int^multiply_int64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_associative","expr":"15 * (23 * 88) == (15 * 23) * 88","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n _*_(\n 23^#*expr.Constant_Int64Value#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15~int,\n _*_(\n 23~int,\n 88~int\n )~int^multiply_int64\n )~int^multiply_int64,\n _*_(\n _*_(\n 15~int,\n 23~int\n )~int^multiply_int64,\n 88~int\n )~int^multiply_int64\n)~bool^equals","type":"bool"},{"original":{"name":"add_mul_distribute","expr":"5 * (15 + 25) == 5 * 15 + 5 * 25","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 5~int,\n _+_(\n 15~int,\n 25~int\n )~int^add_int64\n )~int^multiply_int64,\n _+_(\n _*_(\n 5~int,\n 15~int\n )~int^multiply_int64,\n _*_(\n 5~int,\n 25~int\n )~int^multiply_int64\n )~int^add_int64\n)~bool^equals","type":"bool"},{"original":{"name":"int64_overflow_positive","description":"LLONG_MAX plus one.","expr":"9223372036854775807 + 1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_+_(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 9223372036854775807~int,\n 1~int\n)~int^add_int64","type":"int"},{"original":{"name":"int64_overflow_negative","description":"LLONG_MIN minus one.","expr":"-9223372036854775808 - 1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_-_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n -9223372036854775808~int,\n 1~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"int64_overflow_add_negative","description":"negative overflow via addition","expr":"-9223372036854775808 + (-1)","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_+_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n -9223372036854775808~int,\n -1~int\n)~int^add_int64","type":"int"},{"original":{"name":"int64_overflow_sub_positive","description":"positive overflow via subtraction","expr":"1 - (-9223372036854775807)","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_-_(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 1~int,\n -9223372036854775807~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"int64_min_negate","description":"Negated LLONG_MIN is not representable.","expr":"-(-9223372036854775808)","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"-_(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -9223372036854775808~int\n)~int^negate_int64","type":"int"},{"original":{"name":"int64_min_negate_mul","description":"Negate LLONG_MIN via multiplication","expr":"(-9223372036854775808) * -1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -9223372036854775808~int,\n -1~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"int64_min_negate_div","description":"Negate LLONG_MIN via division.","expr":"(-9223372036854775808)/-1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_/_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -9223372036854775808~int,\n -1~int\n)~int^divide_int64","type":"int"},{"original":{"name":"int64_overflow_mul_positive","description":"Overflow via multiplication.","expr":"5000000000 * 5000000000","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n 5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 5000000000~int,\n 5000000000~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"int64_overflow_mul_negative","description":"Overflow via multiplication.","expr":"(-5000000000) * 5000000000","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n -5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -5000000000~int,\n 5000000000~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"uint64_overflow_positive","description":"ULLONG_MAX plus one.","expr":"18446744073709551615u + 1u","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_+_(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"uint64_overflow_negative","description":"zero minus one.","expr":"0u - 1u","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_-_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 0u~uint,\n 1u~uint\n)~uint^subtract_uint64","type":"uint"},{"original":{"name":"uint64_overflow_mul_positive","description":"Overflow via multiplication.","expr":"5000000000u * 5000000000u","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n 5000000000u^#*expr.Constant_Uint64Value#,\n 5000000000u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 5000000000u~uint,\n 5000000000u~uint\n)~uint^multiply_uint64","type":"uint"}]},{"name":"uint64_math","tests":[{"original":{"name":"add","expr":"42u + 2u","value":{"uint64Value":"44"}},"ast":"_+_(\n 42u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 42u~uint,\n 2u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"sub","expr":"42u - 12u","value":{"uint64Value":"30"}},"ast":"_-_(\n 42u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42u~uint,\n 12u~uint\n)~uint^subtract_uint64","type":"uint"},{"original":{"name":"multiply","expr":"40u * 2u","value":{"uint64Value":"80"}},"ast":"_*_(\n 40u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 40u~uint,\n 2u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"divide","expr":"60u / 2u","value":{"uint64Value":"30"}},"ast":"_/_(\n 60u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 60u~uint,\n 2u~uint\n)~uint^divide_uint64","type":"uint"},{"original":{"name":"mod","expr":"42u % 5u","value":{"uint64Value":"2"}},"ast":"_%_(\n 42u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 42u~uint,\n 5u~uint\n)~uint^modulo_uint64","type":"uint"},{"original":{"name":"negative_no_overload","expr":"-(5u)","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"-_(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(5u)\n | ^"},{"original":{"name":"mod_zero","expr":"34u % 0u","evalError":{"errors":[{"message":"modulus by zero"}]}},"ast":"_%_(\n 34u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 34u~uint,\n 0u~uint\n)~uint^modulo_uint64","type":"uint"},{"original":{"name":"divide_zero","expr":"15u / 0u","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"_/_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 15u~uint,\n 0u~uint\n)~uint^divide_uint64","type":"uint"},{"original":{"name":"multiply_zero","expr":"15u * 0u","value":{"uint64Value":"0"}},"ast":"_*_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 15u~uint,\n 0u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"add_left_identity","expr":"0u + 17u","value":{"uint64Value":"17"}},"ast":"_+_(\n 0u^#*expr.Constant_Uint64Value#,\n 17u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 0u~uint,\n 17u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"add_right_identity","expr":" 29u + 0u","value":{"uint64Value":"29"}},"ast":"_+_(\n 29u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 29u~uint,\n 0u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"add_commutative","expr":"75u + 15u == 15u + 75u","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 75u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 75u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 75u~uint,\n 15u~uint\n )~uint^add_uint64,\n _+_(\n 15u~uint,\n 75u~uint\n )~uint^add_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"add_associative","expr":"5u + (15u + 20u) == (5u + 15u) + 20u","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 5u~uint,\n _+_(\n 15u~uint,\n 20u~uint\n )~uint^add_uint64\n )~uint^add_uint64,\n _+_(\n _+_(\n 5u~uint,\n 15u~uint\n )~uint^add_uint64,\n 20u~uint\n )~uint^add_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_left_identity","expr":"1u * 45u","value":{"uint64Value":"45"}},"ast":"_*_(\n 1u^#*expr.Constant_Uint64Value#,\n 45u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 1u~uint,\n 45u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"mul_right_identity","expr":"25u * 1u","value":{"uint64Value":"25"}},"ast":"_*_(\n 25u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 25u~uint,\n 1u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"mul_commutative","expr":"15u * 25u == 25u * 15u","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15u~uint,\n 25u~uint\n )~uint^multiply_uint64,\n _*_(\n 25u~uint,\n 15u~uint\n )~uint^multiply_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_associative","expr":"15u * (23u * 88u) == (15u * 23u) * 88u","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n _*_(\n 23u^#*expr.Constant_Uint64Value#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 23u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15u~uint,\n _*_(\n 23u~uint,\n 88u~uint\n )~uint^multiply_uint64\n )~uint^multiply_uint64,\n _*_(\n _*_(\n 15u~uint,\n 23u~uint\n )~uint^multiply_uint64,\n 88u~uint\n )~uint^multiply_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"add_mul_distribute","expr":"5u * (15u + 25u) == 5u * 15u + 5u * 25u","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 5u~uint,\n _+_(\n 15u~uint,\n 25u~uint\n )~uint^add_uint64\n )~uint^multiply_uint64,\n _+_(\n _*_(\n 5u~uint,\n 15u~uint\n )~uint^multiply_uint64,\n _*_(\n 5u~uint,\n 25u~uint\n )~uint^multiply_uint64\n )~uint^add_uint64\n)~bool^equals","type":"bool"}]}]},{"name":"lists","suites":[{"name":"concatenation","tests":[{"original":{"name":"list_append","expr":"[0, 1, 2] + [3, 4, 5] == [0, 1, 2, 3, 4, 5]","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"list_not_commutative","expr":"[0, 1, 2] + [3, 4, 5] == [3, 4, 5, 0, 1, 2]","value":{"boolValue":false}},"ast":"_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 3~int,\n 4~int,\n 5~int,\n 0~int,\n 1~int,\n 2~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"list_repeat","expr":"[2] + [2]","value":{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"2"}]}}},"ast":"_+_(\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n [\n 2~int\n ]~list(int),\n [\n 2~int\n ]~list(int)\n)~list(int)^add_list","type":"list(int)"},{"original":{"name":"empty_empty","expr":"[] + []","value":{"listValue":{}}},"ast":"_+_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n []~list(dyn),\n []~list(dyn)\n)~list(dyn)^add_list","type":"list(dyn)"},{"original":{"name":"left_unit","expr":"[] + [3, 4]","value":{"listValue":{"values":[{"int64Value":"3"},{"int64Value":"4"}]}}},"ast":"_+_(\n []^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n []~list(int),\n [\n 3~int,\n 4~int\n ]~list(int)\n)~list(int)^add_list","type":"list(int)"},{"original":{"name":"right_unit","expr":"[1, 2] + []","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"}]}}},"ast":"_+_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n [\n 1~int,\n 2~int\n ]~list(int),\n []~list(int)\n)~list(int)^add_list","type":"list(int)"}]},{"name":"index","tests":[{"original":{"name":"zero_based","expr":"[7, 8, 9][0]","value":{"int64Value":"7"}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n 0~int\n)~int^index_list","type":"int"},{"original":{"name":"zero_based_double","expr":"[7, 8, 9][dyn(0.0)]","value":{"int64Value":"7"}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0~double\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"zero_based_double_error","expr":"[7, 8, 9][dyn(0.1)]","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0.1~double\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"zero_based_uint","expr":"[7, 8, 9][dyn(0u)]","value":{"int64Value":"7"}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0u~uint\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"singleton","expr":"['foo'][0]","value":{"stringValue":"foo"}},"ast":"_[_](\n [\n \"foo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n \"foo\"~string\n ]~list(string),\n 0~int\n)~string^index_list","type":"string"},{"original":{"name":"middle","expr":"[0, 1, 1, 2, 3, 5, 8, 13][4]","value":{"int64Value":"3"}},"ast":"_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 0~int,\n 1~int,\n 1~int,\n 2~int,\n 3~int,\n 5~int,\n 8~int,\n 13~int\n ]~list(int),\n 4~int\n)~int^index_list","type":"int"},{"original":{"name":"last","expr":"['George', 'John', 'Paul', 'Ringo'][3]","value":{"stringValue":"Ringo"}},"ast":"_[_](\n [\n \"George\"^#*expr.Constant_StringValue#,\n \"John\"^#*expr.Constant_StringValue#,\n \"Paul\"^#*expr.Constant_StringValue#,\n \"Ringo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n \"George\"~string,\n \"John\"~string,\n \"Paul\"~string,\n \"Ringo\"~string\n ]~list(string),\n 3~int\n)~string^index_list","type":"string"},{"original":{"name":"index_out_of_bounds","expr":"[1, 2, 3][3]","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n)~int^index_list","type":"int"},{"original":{"name":"index_out_of_bounds_or_false","expr":"dyn([1, 2, 3][3]) || false","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"index_out_of_bounds_or_true","expr":"dyn([1, 2, 3][3]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"index_out_of_bounds_and_false","expr":"dyn([1, 2, 3][3]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"index_out_of_bounds_and_true","expr":"dyn([1, 2, 3][3]) \u0026\u0026 true","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"bad_index_type","expr":"[1, 2, 3][dyn('')]","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"bad_index_type_or_false","expr":"dyn([1, 2, 3][dyn('')]) || false","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"bad_index_type_or_true","expr":"dyn([1, 2, 3][dyn('')]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"bad_index_type_and_false","expr":"dyn([1, 2, 3][dyn('')]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"bad_index_type_and_true","expr":"dyn([1, 2, 3][dyn('')]) \u0026\u0026 true","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"}]},{"name":"in","tests":[{"original":{"name":"empty","expr":"7 in []","value":{"boolValue":false}},"ast":"@in(\n 7^#*expr.Constant_Int64Value#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 7~int,\n []~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"singleton","expr":"4u in [4u]","value":{"boolValue":true}},"ast":"@in(\n 4u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 4u~uint,\n [\n 4u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"first","expr":"'alpha' in ['alpha', 'beta', 'gamma']","value":{"boolValue":true}},"ast":"@in(\n \"alpha\"^#*expr.Constant_StringValue#,\n [\n \"alpha\"^#*expr.Constant_StringValue#,\n \"beta\"^#*expr.Constant_StringValue#,\n \"gamma\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"alpha\"~string,\n [\n \"alpha\"~string,\n \"beta\"~string,\n \"gamma\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"middle","expr":"3 in [5, 4, 3, 2, 1]","value":{"boolValue":true}},"ast":"@in(\n 3^#*expr.Constant_Int64Value#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 3~int,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"last","expr":"20u in [4u, 6u, 8u, 12u, 20u]","value":{"boolValue":true}},"ast":"@in(\n 20u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#,\n 6u^#*expr.Constant_Uint64Value#,\n 8u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 20u~uint,\n [\n 4u~uint,\n 6u~uint,\n 8u~uint,\n 12u~uint,\n 20u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"double_in_ints","expr":"dyn(3.0) in [5, 4, 3, 2, 1]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"uint_in_ints","expr":"dyn(3u) in [5, 4, 3, 2, 1]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"int_in_doubles","expr":"dyn(3) in [5.0, 4.0, 3.0, 2.0, 1.0]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list","type":"bool"},{"original":{"name":"uint_in_doubles","expr":"dyn(3u) in [5.0, 4.0, 3.0, 2.0, 1.0]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list","type":"bool"},{"original":{"name":"int_in_uints","expr":"dyn(3) in [5u, 4u, 3u, 2u, 1u]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"double_in_uints","expr":"dyn(3.0) in [5u, 4u, 3u, 2u, 1u]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"missing","expr":"'hawaiian' in ['meat', 'veggie', 'margarita', 'cheese']","value":{"boolValue":false}},"ast":"@in(\n \"hawaiian\"^#*expr.Constant_StringValue#,\n [\n \"meat\"^#*expr.Constant_StringValue#,\n \"veggie\"^#*expr.Constant_StringValue#,\n \"margarita\"^#*expr.Constant_StringValue#,\n \"cheese\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"hawaiian\"~string,\n [\n \"meat\"~string,\n \"veggie\"~string,\n \"margarita\"~string,\n \"cheese\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"}]},{"name":"size","tests":[{"original":{"name":"list_empty","expr":"size([])","value":{"int64Value":"0"}},"ast":"size(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n []~list(dyn)\n)~int^size_list","type":"int"},{"original":{"name":"list","expr":"size([1, 2, 3])","value":{"int64Value":"3"}},"ast":"size(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~int^size_list","type":"int"},{"original":{"name":"map_empty","expr":"size({})","value":{"int64Value":"0"}},"ast":"size(\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n {}~map(dyn, dyn)\n)~int^size_map","type":"int"},{"original":{"name":"map","expr":"size({1: 'one', 2: 'two', 3: 'three'})","value":{"int64Value":"3"}},"ast":"size(\n {\n 1^#*expr.Constant_Int64Value#:\"one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:\"three\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n {\n 1~int:\"one\"~string,\n 2~int:\"two\"~string,\n 3~int:\"three\"~string\n }~map(int, string)\n)~int^size_map","type":"int"}]}]},{"name":"logic","suites":[{"name":"conditional","tests":[{"original":{"name":"true_case","expr":"true ? 1 : 2","value":{"int64Value":"1"}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"false_case","expr":"false ? 'foo' : 'bar'","value":{"stringValue":"bar"}},"ast":"_?_:_(\n false^#*expr.Constant_BoolValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n false~bool,\n \"foo\"~string,\n \"bar\"~string\n)~string^conditional","type":"string"},{"original":{"name":"error_case","expr":"2 / 0 \u003e 4 ? 'baz' : 'quux'","evalError":{"errors":[{"message":"division by zero"}]}},"ast":"_?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"baz\"^#*expr.Constant_StringValue#,\n \"quux\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n \"baz\"~string,\n \"quux\"~string\n)~string^conditional","type":"string"},{"original":{"name":"mixed_type","expr":"true ? 'cows' : 17","disableCheck":true,"value":{"stringValue":"cows"}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n \"cows\"^#*expr.Constant_StringValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:6: found no matching overload for '_?_:_' applied to '(bool, string, int)'\n | true ? 'cows' : 17\n | .....^"},{"original":{"name":"bad_type","expr":"'cows' ? false : 17","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_?_:_(\n \"cows\"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:8: found no matching overload for '_?_:_' applied to '(string, bool, int)'\n | 'cows' ? false : 17\n | .......^"}]},{"name":"AND","tests":[{"original":{"name":"all_true","expr":"true \u0026\u0026 true","value":{"boolValue":true}},"ast":"_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n true~bool,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"all_false","expr":"false \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n false~bool,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"false_left","expr":"false \u0026\u0026 true","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n false~bool,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"false_right","expr":"true \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n true~bool,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"short_circuit_type_left","expr":"false \u0026\u0026 32","disableCheck":true,"value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: expected type 'bool' but found 'int'\n | false \u0026\u0026 32\n | .........^"},{"original":{"name":"short_circuit_type_right","expr":"'horses' \u0026\u0026 false","disableCheck":true,"value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n \"horses\"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' \u0026\u0026 false\n | ^"},{"original":{"name":"short_circuit_error_left","expr":"false \u0026\u0026 (2 / 0 \u003e 3 ? false : true)","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n false~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_and","type":"bool"},{"original":{"name":"short_circuit_error_right","expr":"(2 / 0 \u003e 3 ? false : true) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"error_right","expr":"true \u0026\u0026 1/0 != 0","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n true~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_and","type":"bool"},{"original":{"name":"error_left","expr":"1/0 != 0 \u0026\u0026 true","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_\u0026\u0026_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"no_overload","expr":"'less filling' \u0026\u0026 'tastes great'","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_\u0026\u0026_(\n \"less filling\"^#*expr.Constant_StringValue#,\n \"tastes great\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ..................^"}]},{"name":"OR","tests":[{"original":{"name":"all_true","expr":"true || true","value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n true~bool,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"all_false","expr":"false || false","value":{"boolValue":false}},"ast":"_||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n false~bool,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"false_left","expr":"false || true","value":{"boolValue":true}},"ast":"_||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n false~bool,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"false_right","expr":"true || false","value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n true~bool,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"short_circuit_type_left","expr":"true || 32","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: expected type 'bool' but found 'int'\n | true || 32\n | ........^"},{"original":{"name":"short_circuit_type_right","expr":"'horses' || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n \"horses\"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' || true\n | ^"},{"original":{"name":"short_circuit_error_left","expr":"true || (2 / 0 \u003e 3 ? false : true)","value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n true~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_or","type":"bool"},{"original":{"name":"short_circuit_error_right","expr":"(2 / 0 \u003e 3 ? false : true) || true","value":{"boolValue":true}},"ast":"_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"error_right","expr":"false || 1/0 != 0","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_||_(\n false^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n false~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_or","type":"bool"},{"original":{"name":"error_left","expr":"1/0 != 0 || false","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_||_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"no_overload","expr":"'less filling' || 'tastes great'","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_||_(\n \"less filling\"^#*expr.Constant_StringValue#,\n \"tastes great\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ..................^"}]},{"name":"NOT","tests":[{"original":{"name":"not_true","expr":"!true","value":{"boolValue":false}},"ast":"!_(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n true~bool\n)~bool^logical_not","type":"bool"},{"original":{"name":"not_false","expr":"!false","value":{"boolValue":true}},"ast":"!_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n false~bool\n)~bool^logical_not","type":"bool"},{"original":{"name":"no_overload","expr":"!0","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"!_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '!_' applied to '(int)'\n | !0\n | ^"}]}]},{"name":"macros","suites":[{"name":"exists","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].exists(e, e \u003e 0)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].exists(e, e == 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].exists(e, e \u003e 3)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_shortcircuit","description":"Exists filter is true for the last element.","expr":"[1, 'foo', 3].exists(e, e != '1')","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n e^#*expr.Expr_IdentExpr#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n e~dyn^e,\n \"1\"~string\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_exhaustive","description":"Exists filter is never true, but heterogenous equality ensure the result is false.","expr":"[1, 'foo', 3].exists(e, e == '10')","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n \"10\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n \"10\"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_exists_error","expr":"[1, 2, 3].exists(e, e / 0 == 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_empty","expr":"[].exists(e, e == 2)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.exists(k, k == 'key2')","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"~string:1~int,\n \"key2\"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n \"key2\"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"not_map_key","expr":"!{'key1':1, 'key2':2}.exists(k, k == 'key3')","value":{"boolValue":true}},"ast":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key3\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"~string:1~int,\n \"key2\"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n \"key3\"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not","type":"bool"},{"original":{"name":"map_key_type_shortcircuit","description":"Exists filter is true for the second key","expr":"{'key':1, 1:21}.exists(k, k != 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"~string:1~int,\n 1~int:21~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n k~dyn^k,\n 2~int\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"map_key_type_exhaustive","description":"Exists filter is never true, but heterogeneous equality ensures the result is false.","expr":"!{'key':1, 1:42}.exists(k, k == 2)","value":{"boolValue":true}},"ast":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"~string:1~int,\n 1~int:42~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~dyn^k,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not","type":"bool"}]},{"name":"all","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].all(e, e \u003e 0)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].all(e, e == 2)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].all(e, e == 17)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 17~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_shortcircuit","expr":"[1, 'foo', 3].all(e, e == 1)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_exhaustive","expr":"[1, 'foo', 3].all(e, e % 2 == 1)","evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _%_(\n e~dyn^e,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_error_shortcircuit","expr":"[1, 2, 3].all(e, 6 / (2 - e) == 6)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n e^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _/_(\n 6~int,\n _-_(\n 2~int,\n e~int^e\n )~int^subtract_int64\n )~int^divide_int64,\n 6~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_error_exhaustive","expr":"[1, 2, 3].all(e, e / 0 != 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _!=_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^not_equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_empty","expr":"[].all(e, e \u003e 0)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.all(k, k == 'key2')","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"~string:1~int,\n \"key2\"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n k~string^k,\n \"key2\"~string\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"}]},{"name":"exists_one","tests":[{"original":{"name":"list_empty","expr":"[].exists_one(a, a == 7)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n a,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n a,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_one_true","expr":"[7].exists_one(a, a == 7)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 7^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 7~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_one_false","expr":"[8].exists_one(a, a == 7)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_none","expr":"[1, 2, 3].exists_one(x, x \u003e 20)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n x^#*expr.Expr_IdentExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n x~int^x,\n 20~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_one","expr":"[6, 7, 8].exists_one(foo, foo % 5 == 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6~int,\n 7~int,\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_many","expr":"[0, 1, 2, 3, 4].exists_one(n, n % 2 == 1)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_all","expr":"['foal', 'foo', 'four'].exists_one(n, n.startsWith('fo'))","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n \"foal\"^#*expr.Constant_StringValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n \"four\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n n^#*expr.Expr_IdentExpr#.startsWith(\n \"fo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n \"foal\"~string,\n \"foo\"~string,\n \"four\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n n~string^n.startsWith(\n \"fo\"~string\n )~bool^starts_with_string,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_no_shortcircuit","description":"Errors invalidate everything, even if already false.","expr":"[3, 2, 1, 0].exists_one(n, 12 / n \u003e 1)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 1~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"map_one","expr":"{6: 'six', 7: 'seven', 8: 'eight'}.exists_one(foo, foo % 5 == 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6^#*expr.Constant_Int64Value#:\"six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:\"seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:\"eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6~int:\"six\"~string,\n 7~int:\"seven\"~string,\n 8~int:\"eight\"~string\n }~map(int, string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"}]},{"name":"map","tests":[{"original":{"name":"list_empty","expr":"[].map(n, n / 2)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_one","expr":"[3].map(n, n * n)","value":{"listValue":{"values":[{"int64Value":"9"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _*_(\n n^#*expr.Expr_IdentExpr#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _*_(\n n~int^n,\n n~int^n\n )~int^multiply_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_many","expr":"[2, 4, 6].map(n, n / 2)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 4~int,\n 6~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_error","expr":"[2, 1, 0].map(n, 4 / n)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n 4^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n 4~int,\n n~int^n\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"map_extract_keys","expr":"{'John': 'smart'}.map(key, key) == ['John']","value":{"boolValue":true}},"ast":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"^#*expr.Constant_StringValue#:\"smart\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n \"John\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"~string:\"smart\"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n // Result\n @result~list(string)^@result)~list(string),\n [\n \"John\"~string\n ]~list(string)\n)~bool^equals","type":"bool"}]},{"name":"filter","tests":[{"original":{"name":"list_empty","expr":"[].filter(n, n % 2 == 0)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 0~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_one_true","expr":"[2].filter(n, n == 2)","value":{"listValue":{"values":[{"int64Value":"2"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n n~int^n,\n 2~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_one_false","expr":"[1].filter(n, n \u003e 3)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_none","expr":"[1, 2, 3].filter(e, e \u003e 3)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n e^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n e~int^e\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_some","expr":"[0, 1, 2, 3, 4].filter(x, x % 2 == 1)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"3"}]}}},"ast":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x~int^x,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n x~int^x\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_all","expr":"[1, 2, 3].filter(n, n \u003e 0)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 0~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_no_shortcircuit","expr":"[3, 2, 1, 0].filter(n, 12 / n \u003e 4)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"map_filter_keys","expr":"{'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}.filter(key, key == 'Ringo') == ['Ringo']","value":{"boolValue":true}},"ast":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"^#*expr.Constant_StringValue#:\"smart\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Paul\"^#*expr.Constant_StringValue#:\"cute\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"George\"^#*expr.Constant_StringValue#:\"quiet\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Ringo\"^#*expr.Constant_StringValue#:\"funny\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n key^#*expr.Expr_IdentExpr#,\n \"Ringo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n \"Ringo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"~string:\"smart\"~string,\n \"Paul\"~string:\"cute\"~string,\n \"George\"~string:\"quiet\"~string,\n \"Ringo\"~string:\"funny\"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n key~string^key,\n \"Ringo\"~string\n )~bool^equals,\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string),\n [\n \"Ringo\"~string\n ]~list(string)\n)~bool^equals","type":"bool"}]},{"name":"nested","tests":[{"original":{"name":"filter_all","expr":"['signer'].filter(signer, ['artifact'].all(artifact, true))","value":{"listValue":{"values":[{"stringValue":"signer"}]}}},"ast":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n signer^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool,\n _+_(\n @result~list(string)^@result,\n [\n signer~string^signer\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string)","type":"list(string)"},{"original":{"name":"all_all","expr":"['signer'].all(signer, ['artifact'].all(artifact, true))","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"}]}]},{"name":"macros2","suites":[{"name":"exists","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................................^"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................................^"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................................^"},{"original":{"name":"list_elem_type_shortcircuit","expr":"[1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................................^"},{"original":{"name":"list_elem_type_exhaustive","expr":"[1, 'foo', 3].exists(i, v, i == 3 || v == '10')","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"10\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................................^"},{"original":{"name":"list_elem_exists_error","expr":"[1, 2, 3].exists(i, v, v / i == 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ...........................^"},{"original":{"name":"list_empty","expr":"[].exists(i, v, i == 0 || v == 2)","value":{"boolValue":false}},"ast":"[]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: undeclared reference to 'exists' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .........^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........................^"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)","value":{"boolValue":true}},"ast":"{\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: undeclared reference to 'exists' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..................................^\nERROR: \u003cinput\u003e:1:50: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .................................................^"},{"original":{"name":"not_map_key","expr":"!{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)","value":{"boolValue":true}},"ast":"!_(\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key3\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:29: undeclared reference to 'exists' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ............................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ................................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ...................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ..................................................^"},{"original":{"name":"map_key_type_shortcircuit","expr":"{'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)","value":{"boolValue":true}},"ast":"{\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:23: undeclared reference to 'exists' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .............................^\nERROR: \u003cinput\u003e:1:40: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................................^"},{"original":{"name":"map_key_type_exhaustive","expr":"!{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)","value":{"boolValue":true}},"ast":"!_(\n {\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 43^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'exists' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................................^"}]},{"name":"all","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............................^"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............................^"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].all(i, v, i == 3 || v == 4)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............................^"},{"original":{"name":"list_elem_type_shortcircuit","expr":"[1, 'foo', 3].all(i, v, i == 0 || v == 1)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................................^"},{"original":{"name":"list_elem_type_exhaustive","expr":"[0, 'foo', 3].all(i, v, v % 2 == i)","value":{"boolValue":false}},"ast":"[\n 0^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................................^"},{"original":{"name":"list_elem_type_error_exhaustive","expr":"[0, 'foo', 5].all(i, v, v % 3 == i)","evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"[\n 0^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................................^"},{"original":{"name":"list_elem_error_shortcircuit","expr":"[1, 2, 3].all(i, v, 6 / (2 - v) == i)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ...................................^"},{"original":{"name":"list_elem_error_exhaustive","expr":"[1, 2, 3].all(i, v, v / i != 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ........................^"},{"original":{"name":"list_empty","expr":"[].all(i, v, i \u003e -1 || v \u003e 0)","value":{"boolValue":true}},"ast":"[]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: undeclared reference to 'all' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ......^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......................^"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)","value":{"boolValue":false}},"ast":"{\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.all(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:25: undeclared reference to 'all' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ........................^\nERROR: \u003cinput\u003e:1:26: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..............................................^"}]},{"name":"existsOne","tests":[{"original":{"name":"list_empty","expr":"[].existsOne(i, v, i == 3 || v == 7)","value":{"boolValue":false}},"ast":"[]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: undeclared reference to 'existsOne' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ............^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ...................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............................^"},{"original":{"name":"list_one_true","expr":"[7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)","value":{"boolValue":true}},"ast":"[\n 7^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^"},{"original":{"name":"list_one_false","expr":"[8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)","value":{"boolValue":false}},"ast":"[\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^"},{"original":{"name":"list_none","expr":"[1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................................^"},{"original":{"name":"list_one","expr":"[5, 7, 8].existsOne(i, v, v % 5 == i)","value":{"boolValue":true}},"ast":"[\n 5^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................................^"},{"original":{"name":"list_many","expr":"[0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)","value":{"boolValue":false}},"ast":"[\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:26: undeclared reference to 'existsOne' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................................^"},{"original":{"name":"list_all","expr":"['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))","value":{"boolValue":false}},"ast":"[\n \"foal\"^#*expr.Constant_StringValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n \"four\"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#.startsWith(\n \"fo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:34: undeclared reference to 'existsOne' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .................................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .....................................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ........................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................................^"},{"original":{"name":"list_no_shortcircuit","expr":"[3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:23: undeclared reference to 'existsOne' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .............................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .................................^"},{"original":{"name":"map_one","expr":"{6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')","value":{"boolValue":true}},"ast":"{\n 6^#*expr.Constant_Int64Value#:\"six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:\"seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:\"eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.existsOne(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n _%_(\n k^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"seven\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:45: undeclared reference to 'existsOne' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ............................................^\nERROR: \u003cinput\u003e:1:46: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .............................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ................................................^\nERROR: \u003cinput\u003e:1:52: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ...................................................^\nERROR: \u003cinput\u003e:1:66: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .................................................................^"}]},{"name":"transformList","tests":[{"original":{"name":"empty","expr":"[].transformList(i, v, i / v)","value":{"listValue":{}}},"ast":"[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ...........................^"},{"original":{"name":"empty_filter","expr":"[].transformList(i, v, i \u003e v, i / v)","value":{"listValue":{}}},"ast":"[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..................................^"},{"original":{"name":"one","expr":"[3].transformList(i, v, v * v + i)","value":{"listValue":{"values":[{"int64Value":"9"}]}}},"ast":"[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ................................^"},{"original":{"name":"one_filter","expr":"[3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)","value":{"listValue":{"values":[{"int64Value":"9"}]}}},"ast":"[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................^\nERROR: \u003cinput\u003e:1:43: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..........................................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................................^"},{"original":{"name":"many","expr":"[2, 4, 6].transformList(i, v, v / 2 + i)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"3"},{"int64Value":"5"}]}}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ......................................^"},{"original":{"name":"many_filter","expr":"[2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"5"}]}}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ................................................^\nERROR: \u003cinput\u003e:1:57: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................................^"},{"original":{"name":"error","expr":"[2, 1, 0].transformList(i, v, v / i)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..................................^"},{"original":{"name":"error_filter","expr":"[2, 1, 0].transformList(i, v, v / i \u003e 0, v)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .........................................^"}]},{"name":"transformMap","tests":[{"original":{"name":"empty","expr":"{}.transformMap(k, v, k + v)","value":{"mapValue":{}}},"ast":"{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ..........................^"},{"original":{"name":"empty_filter","expr":"{}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)","value":{"mapValue":{}}},"ast":"{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"foo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"bar\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:37: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:53: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................................^"},{"original":{"name":"one","expr":"{'foo': 'bar'}.transformMap(k, v, k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ......................................^"},{"original":{"name":"one_filter","expr":"{'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"foo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"bar\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:65: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................................^"},{"original":{"name":"many","expr":"{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}},{"key":{"stringValue":"baz"},"value":{"stringValue":"bazbux"}},{"key":{"stringValue":"hello"},"value":{"stringValue":"helloworld"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:\"bux\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"hello\"^#*expr.Constant_StringValue#:\"world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:71: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ......................................................................^"},{"original":{"name":"many_filter","expr":"{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}},{"key":{"stringValue":"hello"},"value":{"stringValue":"helloworld"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:\"bux\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"hello\"^#*expr.Constant_StringValue#:\"world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n \"baz\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n \"bux\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:81: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................^\nERROR: \u003cinput\u003e:1:93: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................................................^\nERROR: \u003cinput\u003e:1:97: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................................^"},{"original":{"name":"error","expr":"{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"bar\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:55: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ......................................................^"},{"original":{"name":"error_filter","expr":"{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"bar\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"baz\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ..................................................^\nERROR: \u003cinput\u003e:1:69: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ....................................................................^\nERROR: \u003cinput\u003e:1:77: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................................................^"}]}]},{"name":"math_ext","suites":[{"name":"greatest_int_result","tests":[{"original":{"name":"unary_negative","expr":"math.greatest(-5)","value":{"int64Value":"-5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -5~int\n)~int^math_@max_int","type":"int"},{"original":{"name":"unary_positive","expr":"math.greatest(5)","value":{"int64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5~int\n)~int^math_@max_int","type":"int"},{"original":{"name":"binary_same_args","expr":"math.greatest(1, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n 1~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_with_decimal","expr":"math.greatest(1, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~int,\n 1~double\n )~dyn^math_@max_int_double,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.greatest(1, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~int,\n 1u~uint\n )~dyn^math_@max_int_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_greater","expr":"math.greatest(3, -3)","value":{"int64Value":"3"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 3^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 3~int,\n -3~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_second_arg_greater","expr":"math.greatest(-7, 5)","value":{"int64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -7^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -7~int,\n 5~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_max","expr":"math.greatest(9223372036854775807, 1)","value":{"int64Value":"9223372036854775807"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 9223372036854775807~int,\n 1~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_max","expr":"math.greatest(1, 9223372036854775807)","value":{"int64Value":"9223372036854775807"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n 9223372036854775807~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_min","expr":"math.greatest(-9223372036854775808, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -9223372036854775808~int,\n 1~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_min","expr":"math.greatest(1, -9223372036854775808)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n -9223372036854775808~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"ternary_same_args","expr":"math.greatest(1, 1, 1) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@max_list_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.greatest(1, 1.0, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.greatest(1, 1u, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_greatest","expr":"math.greatest(10, 1, 3) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 10~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_greatest","expr":"math.greatest(1, 3, 10) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 3~int,\n 10~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.greatest(-1, -2, -3) == -1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_max","expr":"math.greatest(9223372036854775807, 1, 5) == 9223372036854775807"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@max_list_int,\n 9223372036854775807~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_min","expr":"math.greatest(-9223372036854775807, -1, -5) == -1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775807^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -9223372036854775807~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.greatest(5.4, 10, 3u, -5.0, 9223372036854775807) == 9223372036854775807"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 9223372036854775807~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.greatest([5.4, 10, 3u, -5.0, 3.5]) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.greatest([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals","type":"bool"}]},{"name":"greatest_double_result","tests":[{"original":{"name":"unary_negative","expr":"math.greatest(-5.0)","value":{"doubleValue":-5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -5~double\n)~double^math_@max_double","type":"double"},{"original":{"name":"unary_positive","expr":"math.greatest(5.0)","value":{"doubleValue":5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5~double\n)~double^math_@max_double","type":"double"},{"original":{"name":"binary_same_args","expr":"math.greatest(1.0, 1.0)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~double,\n 1~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_with_int","expr":"math.greatest(1.0, 1) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~double,\n 1~int\n )~dyn^math_@max_double_int,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.greatest(1.0, 1u) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~double,\n 1u~uint\n )~dyn^math_@max_double_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_greater","expr":"math.greatest(5.0, -7.0)","value":{"doubleValue":5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#,\n -7^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5~double,\n -7~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_second_arg_greater","expr":"math.greatest(-3.0, 3.0)","value":{"doubleValue":3}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -3~double,\n 3~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_first_arg_double_max","expr":"math.greatest(1.797693e308, 1)","value":{"doubleValue":1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1.797693e+308~double,\n 1~int\n)~dyn^math_@max_double_int","type":"dyn"},{"original":{"name":"binary_second_arg_double_max","expr":"math.greatest(1, 1.797693e308)","value":{"doubleValue":1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n 1.797693e+308~double\n)~dyn^math_@max_int_double","type":"dyn"},{"original":{"name":"binary_first_arg_double_min","expr":"math.greatest(-1.797693e308, 1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_second_arg_double_min","expr":"math.greatest(1.5, -1.797693e308)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"ternary_same_args","expr":"math.greatest(1.0, 1.0, 1.0) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~double,\n 1~double,\n 1~double\n ]~list(double)\n )~double^math_@max_list_double,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.greatest(1.0, 1, 1) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.greatest(1.0, 1u, 1u) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_greatest","expr":"math.greatest(10.5, 1.5, 3.5) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 10.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_greatest","expr":"math.greatest(1.5, 3.5, 10.5) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1.5~double,\n 3.5~double,\n 10.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.greatest(-1.5, -2.5, -3.5) == -1.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n -1.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_max","expr":"math.greatest(1.797693e308, 1, 5) == 1.797693e308"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_min","expr":"math.greatest(-1.797693e308, -1, -5) == -1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.greatest(5.4, 10, 3u, -5.0, 1.797693e308) == 1.797693e308"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.greatest([5.4, 10.5, 3u, -5.0, 3.5]) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.greatest([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals","type":"bool"}]},{"name":"greatest_uint_result","tests":[{"original":{"name":"unary","expr":"math.greatest(5u)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5u~uint\n)~uint^math_@max_uint","type":"uint"},{"original":{"name":"binary_same_args","expr":"math.greatest(1u, 1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint","type":"uint"},{"original":{"name":"binary_with_decimal","expr":"math.greatest(1u, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1u~uint,\n 1~double\n )~dyn^math_@max_uint_double,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_int","expr":"math.greatest(1u, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1u~uint,\n 1~int\n )~dyn^math_@max_uint_int,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_greater","expr":"math.greatest(5u, -7)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5u~uint,\n -7~int\n)~dyn^math_@max_uint_int","type":"dyn"},{"original":{"name":"binary_second_arg_greater","expr":"math.greatest(-3, 3u)","value":{"uint64Value":"3"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -3~int,\n 3u~uint\n)~dyn^math_@max_int_uint","type":"dyn"},{"original":{"name":"binary_first_arg_uint_max","expr":"math.greatest(18446744073709551615u, 1u)","value":{"uint64Value":"18446744073709551615"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint","type":"uint"},{"original":{"name":"binary_second_arg_uint_max","expr":"math.greatest(1u, 18446744073709551615u)","value":{"uint64Value":"18446744073709551615"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@max_uint_uint","type":"uint"},{"original":{"name":"ternary_same_args","expr":"math.greatest(1u, 1u, 1u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.greatest(1u, 1.0, 1.0) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.greatest(1u, 1, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_greatest","expr":"math.greatest(10u, 1u, 3u) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 10u~uint,\n 1u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_greatest","expr":"math.greatest(1u, 3u, 10u) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 3u~uint,\n 10u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_max","expr":"math.greatest(18446744073709551615u, 1u, 5u) == 18446744073709551615u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.greatest(5.4, 10, 3u, -5.0, 18446744073709551615u) == 18446744073709551615u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.greatest([5.4, 10u, 3u, -5.0, 3.5]) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.greatest([dyn(5.4), dyn(10u), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"}]},{"name":"least_int_result","tests":[{"original":{"name":"unary_negative","expr":"math.least(-5)","value":{"int64Value":"-5"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -5~int\n)~int^math_@min_int","type":"int"},{"original":{"name":"unary_positive","expr":"math.least(5)","value":{"int64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5~int\n)~int^math_@min_int","type":"int"},{"original":{"name":"binary_same_args","expr":"math.least(1, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1~int,\n 1~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_with_decimal","expr":"math.least(1, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~int,\n 1~double\n )~dyn^math_@min_int_double,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.least(1, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_least","expr":"math.least(-3, 3)","value":{"int64Value":"-3"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -3~int,\n 3~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_second_arg_least","expr":"math.least(5, -7)","value":{"int64Value":"-7"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5~int,\n -7~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_max","expr":"math.least(9223372036854775807, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 9223372036854775807~int,\n 1~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_max","expr":"math.least(1, 9223372036854775807)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1~int,\n 9223372036854775807~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_min","expr":"math.least(-9223372036854775808, 1)","value":{"int64Value":"-9223372036854775808"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -9223372036854775808~int,\n 1~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_min","expr":"math.least(1, -9223372036854775808)","value":{"int64Value":"-9223372036854775808"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1~int,\n -9223372036854775808~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"ternary_same_args","expr":"math.least(1, 1, 1) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.least(1, 1.0, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.least(1, 1u, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_least","expr":"math.least(0, 1, 3) == 0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 0~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_least","expr":"math.least(1, 3, 0) == 0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 3~int,\n 0~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.least(-1, -2, -3) == -3"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@min_list_int,\n -3~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_max","expr":"math.least(9223372036854775807, 1, 5) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_min","expr":"math.least(-9223372036854775808, -1, -5) == -9223372036854775808"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -9223372036854775808~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@min_list_int,\n -9223372036854775808~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.least(5.4, 10, 3u, -5.0, 9223372036854775807) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.least([5.4, 10, 3u, -5.0, 3.5]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.least([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"}]},{"name":"least_double_result","tests":[{"original":{"name":"unary_negative","expr":"math.least(-5.5)","value":{"doubleValue":-5.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -5.5~double\n)~double^math_@min_double","type":"double"},{"original":{"name":"unary_positive","expr":"math.least(5.5)","value":{"doubleValue":5.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5.5~double\n)~double^math_@min_double","type":"double"},{"original":{"name":"binary_same_args","expr":"math.least(1.5, 1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.5~double,\n 1.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_with_int","expr":"math.least(1.0, 1) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~double,\n 1~int\n )~dyn^math_@min_double_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.least(1, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_least","expr":"math.least(-3.5, 3.5)","value":{"doubleValue":-3.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -3.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -3.5~double,\n 3.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_second_arg_least","expr":"math.least(5.5, -7.5)","value":{"doubleValue":-7.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#,\n -7.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5.5~double,\n -7.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_first_arg_double_max","expr":"math.least(1.797693e308, 1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_second_arg_double_max","expr":"math.least(1.5, 1.797693e308)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.5~double,\n 1.797693e+308~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_first_arg_double_min","expr":"math.least(-1.797693e308, 1.5)","value":{"doubleValue":-1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_second_arg_double_min","expr":"math.least(1.5, -1.797693e308)","value":{"doubleValue":-1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"ternary_same_args","expr":"math.least(1.5, 1.5, 1.5) == 1.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1.5~double,\n 1.5~double,\n 1.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 1.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.least(1.0, 1, 1) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.least(1.0, 1u, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_least","expr":"math.least(0.5, 1.5, 3.5) == 0.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 0.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_least","expr":"math.least(1.5, 3.5, 0.5) == 0.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 0.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1.5~double,\n 3.5~double,\n 0.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.least(-1.5, -2.5, -3.5) == -3.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n -3.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_max","expr":"math.least(1.797693e308, 1, 5) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_min","expr":"math.least(-1.797693e308, -1, -5) == -1.797693e308"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -1.797693e+308~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.least(5.4, 10, 3u, -5.0, 1.797693e308) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.least([5.4, 10.5, 3u, -5.0, 3.5]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.least([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"}]},{"name":"least_uint_result","tests":[{"original":{"name":"unary","expr":"math.least(5u)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5u~uint\n)~uint^math_@min_uint","type":"uint"},{"original":{"name":"binary_same_args","expr":"math.least(1u, 1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_with_decimal","expr":"math.least(1u, 1.0) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1u~uint,\n 1~double\n )~dyn^math_@min_uint_double,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_int","expr":"math.least(1u, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1u~uint,\n 1~int\n )~dyn^math_@min_uint_int,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_least","expr":"math.least(1u, 3u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1u~uint,\n 3u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_second_arg_least","expr":"math.least(5u, 2u)","value":{"uint64Value":"2"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5u~uint,\n 2u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_first_arg_uint_max","expr":"math.least(18446744073709551615u, 1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_second_arg_uint_max","expr":"math.least(1u, 18446744073709551615u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"ternary_same_args","expr":"math.least(1u, 1u, 1u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.least(1u, 1.0, 1.0) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.least(1u, 1, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_least","expr":"math.least(1u, 10u, 3u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 10u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_least","expr":"math.least(10u, 3u, 1u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 10u~uint,\n 3u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_uint_max","expr":"math.least(18446744073709551615u, 1u, 5u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.least(5.4, 10, 3u, 1u, 18446744073709551615u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n 1u~uint,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.least([5.4, 10u, 3u, 1u, 3.5]) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n 1u~uint,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.least([dyn(5.4), dyn(10u), dyn(3u), dyn(1u), dyn(3.5)]) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"}]},{"name":"ceil","tests":[{"original":{"name":"negative","expr":"math.ceil(-1.2)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.ceil(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.ceil(\n -1.2~double\n)~double^math_ceil_double","type":"double"},{"original":{"name":"positive","expr":"math.ceil(1.2)","value":{"doubleValue":2}},"ast":"math^#*expr.Expr_IdentExpr#.ceil(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.ceil(\n 1.2~double\n)~double^math_ceil_double","type":"double"},{"original":{"name":"dyn_error","expr":"math.ceil(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.ceil(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.ceil(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_ceil_double","type":"double"}]},{"name":"floor","tests":[{"original":{"name":"negative","expr":"math.floor(-1.2)","value":{"doubleValue":-2}},"ast":"math^#*expr.Expr_IdentExpr#.floor(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.floor(\n -1.2~double\n)~double^math_floor_double","type":"double"},{"original":{"name":"positive","expr":"math.floor(1.2)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.floor(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.floor(\n 1.2~double\n)~double^math_floor_double","type":"double"},{"original":{"name":"dyn_error","expr":"math.floor(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.floor(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.floor(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_floor_double","type":"double"}]},{"name":"round","tests":[{"original":{"name":"negative_down","expr":"math.round(-1.6)","value":{"doubleValue":-2}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n -1.6^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n -1.6~double\n)~double^math_round_double","type":"double"},{"original":{"name":"negative_up","expr":"math.round(-1.4)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n -1.4^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n -1.4~double\n)~double^math_round_double","type":"double"},{"original":{"name":"negative_mid","expr":"math.round(-1.5)","value":{"doubleValue":-2}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n -1.5~double\n)~double^math_round_double","type":"double"},{"original":{"name":"positive_down","expr":"math.round(1.2)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n 1.2~double\n)~double^math_round_double","type":"double"},{"original":{"name":"positive_up","expr":"math.round(1.5)","value":{"doubleValue":2}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n 1.5~double\n)~double^math_round_double","type":"double"},{"original":{"name":"nan","expr":"math.isNaN(math.round(0.0/0.0))"},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.round(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n math.round(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_round_double\n)~bool^math_isNaN_double","type":"bool"},{"original":{"name":"dyn_error","expr":"math.round(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_round_double","type":"double"}]},{"name":"trunc","tests":[{"original":{"name":"negative","expr":"math.trunc(-1.2)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.trunc(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.trunc(\n -1.2~double\n)~double^math_trunc_double","type":"double"},{"original":{"name":"positive","expr":"math.trunc(1.2)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.trunc(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.trunc(\n 1.2~double\n)~double^math_trunc_double","type":"double"},{"original":{"name":"nan","expr":"math.isNaN(math.trunc(0.0/0.0))"},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.trunc(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n math.trunc(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_trunc_double\n)~bool^math_isNaN_double","type":"bool"},{"original":{"name":"dyn_error","expr":"math.trunc(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.trunc(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.trunc(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_trunc_double","type":"double"}]},{"name":"abs","tests":[{"original":{"name":"uint","expr":"math.abs(1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n 1u~uint\n)~uint^math_abs_uint","type":"uint"},{"original":{"name":"positive_int","expr":"math.abs(1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n 1~int\n)~int^math_abs_int","type":"int"},{"original":{"name":"negative_int","expr":"math.abs(-11)","value":{"int64Value":"11"}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n -11~int\n)~int^math_abs_int","type":"int"},{"original":{"name":"positive_double","expr":"math.abs(1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n 1.5~double\n)~double^math_abs_double","type":"double"},{"original":{"name":"negative_double","expr":"math.abs(-11.5)","value":{"doubleValue":11.5}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n -11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n -11.5~double\n)~double^math_abs_double","type":"double"},{"original":{"name":"int_overflow","expr":"math.abs(-9223372036854775808)","evalError":{"errors":[{"message":"overflow"}]}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n -9223372036854775808~int\n)~int^math_abs_int","type":"int"}]},{"name":"sign","tests":[{"original":{"name":"positive_uint","expr":"math.sign(100u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 100u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 100u~uint\n)~uint^math_sign_uint","type":"uint"},{"original":{"name":"zero_uint","expr":"math.sign(0u)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 0u~uint\n)~uint^math_sign_uint","type":"uint"},{"original":{"name":"positive_int","expr":"math.sign(100)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 100^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 100~int\n)~int^math_sign_int","type":"int"},{"original":{"name":"negative_int","expr":"math.sign(-11)","value":{"int64Value":"-1"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n -11~int\n)~int^math_sign_int","type":"int"},{"original":{"name":"zero_int","expr":"math.sign(0)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 0~int\n)~int^math_sign_int","type":"int"},{"original":{"name":"positive_double","expr":"math.sign(100.5)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 100.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 100.5~double\n)~double^math_sign_double","type":"double"},{"original":{"name":"negative_double","expr":"math.sign(-32.0)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n -32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n -32~double\n)~double^math_sign_double","type":"double"},{"original":{"name":"zero_double","expr":"math.sign(0.0)","value":{"doubleValue":0}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 0~double\n)~double^math_sign_double","type":"double"},{"original":{"name":"dyn_error","expr":"math.sign(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~dyn^math_sign_double|math_sign_int|math_sign_uint","type":"dyn"}]},{"name":"isNaN","tests":[{"original":{"name":"true","expr":"math.isNaN(0.0/0.0)"},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^math_isNaN_double","type":"bool"},{"original":{"name":"false","expr":"!math.isNaN(1.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isNaN(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isNaN_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"dyn_error","expr":"math.isNaN(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isNaN_double","type":"bool"}]},{"name":"isInf","tests":[{"original":{"name":"true","expr":"math.isInf(1.0/0.0)"},"ast":"math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isInf(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n)~bool^math_isInf_double","type":"bool"},{"original":{"name":"false","expr":"!math.isInf(0.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isInf(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isInf_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"dyn_error","expr":"math.isInf(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.isInf(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isInf(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isInf_double","type":"bool"}]},{"name":"isFinite","tests":[{"original":{"name":"true","expr":"math.isFinite(1.0/1.5)"},"ast":"math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isFinite(\n _/_(\n 1~double,\n 1.5~double\n )~double^divide_double\n)~bool^math_isFinite_double","type":"bool"},{"original":{"name":"false_nan","expr":"!math.isFinite(0.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isFinite(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"false_inf","expr":"!math.isFinite(-1.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n -1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isFinite(\n _/_(\n -1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"dyn_error","expr":"math.isFinite(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.isFinite(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isFinite(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isFinite_double","type":"bool"}]},{"name":"bit_and","tests":[{"original":{"name":"int_int_non_intersect","expr":"math.bitAnd(1, 2)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1~int,\n 2~int\n)~int^math_bitAnd_int_int","type":"int"},{"original":{"name":"int_int_intersect","expr":"math.bitAnd(1, 3)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1~int,\n 3~int\n)~int^math_bitAnd_int_int","type":"int"},{"original":{"name":"int_int_intersect_neg","expr":"math.bitAnd(1, -1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1~int,\n -1~int\n)~int^math_bitAnd_int_int","type":"int"},{"original":{"name":"uint_uint_non_intersect","expr":"math.bitAnd(1u, 2u)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1u~uint,\n 2u~uint\n)~uint^math_bitAnd_uint_uint","type":"uint"},{"original":{"name":"uint_uint_intersect","expr":"math.bitAnd(1u, 3u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1u~uint,\n 3u~uint\n)~uint^math_bitAnd_uint_uint","type":"uint"},{"original":{"name":"int_dyn_error","expr":"math.bitAnd(2u, dyn(''))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 2u^#*expr.Constant_Uint64Value#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 2u~uint,\n dyn(\n \"\"~string\n )~dyn^to_dyn\n)~uint^math_bitAnd_uint_uint","type":"uint"}]},{"name":"bit_or","tests":[{"original":{"name":"int_int_positive","expr":"math.bitOr(1, 2)","value":{"int64Value":"3"}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n 1~int,\n 2~int\n)~int^math_bitOr_int_int","type":"int"},{"original":{"name":"int_int_positive_negative","expr":"math.bitOr(4, -2)","value":{"int64Value":"-2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n 4~int,\n -2~int\n)~int^math_bitOr_int_int","type":"int"},{"original":{"name":"uint_uint","expr":"math.bitOr(1u, 4u)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n 1u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n 1u~uint,\n 4u~uint\n)~uint^math_bitOr_uint_uint","type":"uint"},{"original":{"name":"dyn_int_error","expr":"math.bitOr(dyn(1.2), 1)","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n dyn(\n 1.2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n dyn(\n 1.2~double\n )~dyn^to_dyn,\n 1~int\n)~int^math_bitOr_int_int","type":"int"}]},{"name":"bit_xor","tests":[{"original":{"name":"int_int_positive","expr":"math.bitXor(1, 3)","value":{"int64Value":"2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n 1~int,\n 3~int\n)~int^math_bitXor_int_int","type":"int"},{"original":{"name":"int_int_positive_negative","expr":"math.bitXor(4, -2)","value":{"int64Value":"-6"}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n 4~int,\n -2~int\n)~int^math_bitXor_int_int","type":"int"},{"original":{"name":"uint_uint","expr":"math.bitXor(1u, 3u)","value":{"uint64Value":"2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n 1u~uint,\n 3u~uint\n)~uint^math_bitXor_uint_uint","type":"uint"},{"original":{"name":"dyn_dyn_error","expr":"math.bitXor(dyn([]), dyn([1]))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n dyn(\n [\n 1~int\n ]~list(int)\n )~dyn^to_dyn\n)~dyn^math_bitXor_int_int|math_bitXor_uint_uint","type":"dyn"}]},{"name":"bit_not","tests":[{"original":{"name":"int_positive","expr":"math.bitNot(1)","value":{"int64Value":"-2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 1~int\n)~int^math_bitNot_int_int","type":"int"},{"original":{"name":"int_negative","expr":"math.bitNot(-1)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n -1~int\n)~int^math_bitNot_int_int","type":"int"},{"original":{"name":"int_zero","expr":"math.bitNot(0)","value":{"int64Value":"-1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 0~int\n)~int^math_bitNot_int_int","type":"int"},{"original":{"name":"uint_positive","expr":"math.bitNot(1u)","value":{"uint64Value":"18446744073709551614"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 1u~uint\n)~uint^math_bitNot_uint_uint","type":"uint"},{"original":{"name":"uint_zero","expr":"math.bitNot(0u)","value":{"uint64Value":"18446744073709551615"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 0u~uint\n)~uint^math_bitNot_uint_uint","type":"uint"},{"original":{"name":"dyn_error","expr":"math.bitNot(dyn(''))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n dyn(\n \"\"~string\n )~dyn^to_dyn\n)~dyn^math_bitNot_int_int|math_bitNot_uint_uint","type":"dyn"}]},{"name":"bit_shift_left","tests":[{"original":{"name":"int","expr":"math.bitShiftLeft(1, 2)","value":{"int64Value":"4"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1~int,\n 2~int\n)~int^math_bitShiftLeft_int_int","type":"int"},{"original":{"name":"int_large_shift","expr":"math.bitShiftLeft(1, 200)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int","type":"int"},{"original":{"name":"int_negative_large_shift","expr":"math.bitShiftLeft(-1, 200)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n -1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n -1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int","type":"int"},{"original":{"name":"uint","expr":"math.bitShiftLeft(1u, 2)","value":{"uint64Value":"4"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1u~uint,\n 2~int\n)~uint^math_bitShiftLeft_uint_int","type":"uint"},{"original":{"name":"uint_large_shift","expr":"math.bitShiftLeft(1u, 200)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1u~uint,\n 200~int\n)~uint^math_bitShiftLeft_uint_int","type":"uint"},{"original":{"name":"bad_shift","expr":"math.bitShiftLeft(1u, -1)","evalError":{"errors":[{"message":"negative offset"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftLeft_uint_int","type":"uint"},{"original":{"name":"dyn_int_error","expr":"math.bitShiftLeft(dyn(4.3), 1)","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n dyn(\n 4.3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n dyn(\n 4.3~double\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftLeft_int_int|math_bitShiftLeft_uint_int","type":"dyn"}]},{"name":"bit_shift_right","tests":[{"original":{"name":"int","expr":"math.bitShiftRight(1024, 2)","value":{"int64Value":"256"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024~int,\n 2~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"int_large_shift","expr":"math.bitShiftRight(1024, 64)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"int_negative","expr":"math.bitShiftRight(-1024, 3)","value":{"int64Value":"2305843009213693824"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n -1024~int,\n 3~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"int_negative_large_shift","expr":"math.bitShiftRight(-1024, 64)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n -1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"uint","expr":"math.bitShiftRight(1024u, 2)","value":{"uint64Value":"256"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024u~uint,\n 2~int\n)~uint^math_bitShiftRight_uint_int","type":"uint"},{"original":{"name":"uint_large_shift","expr":"math.bitShiftRight(1024u, 200)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024u~uint,\n 200~int\n)~uint^math_bitShiftRight_uint_int","type":"uint"},{"original":{"name":"bad_shift","expr":"math.bitShiftRight(1u, -1)","evalError":{"errors":[{"message":"negative offset"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftRight_uint_int","type":"uint"},{"original":{"name":"dyn_int_error","expr":"math.bitShiftRight(dyn(b'123'), 1)","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n dyn(\n b\"123\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n dyn(\n b\"123\"~bytes\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftRight_int_int|math_bitShiftRight_uint_int","type":"dyn"}]}]},{"name":"namespace","suites":[{"name":"qualified","tests":[{"original":{"name":"self_eval_qualified_lookup","expr":"x.y","typeEnv":[{"name":"x.y","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"x.y":{"value":{"boolValue":true}}},"value":{"boolValue":true}},"ast":"x^#*expr.Expr_IdentExpr#.y^#*expr.Expr_SelectExpr#","checkedAst":"x.y~bool^x.y","type":"bool"}]},{"name":"namespace","tests":[{"original":{"name":"self_eval_container_lookup","expr":"y","typeEnv":[{"name":"x.y","ident":{"type":{"primitive":"BOOL"}}},{"name":"y","ident":{"type":{"primitive":"STRING"}}}],"container":"x","bindings":{"x.y":{"value":{"boolValue":true}},"y":{"value":{"stringValue":"false"}}},"value":{"boolValue":true}},"ast":"y^#*expr.Expr_IdentExpr#","checkedAst":"x.y~bool^x.y","type":"bool"},{"original":{"name":"self_eval_container_lookup_unchecked","expr":"y","disableCheck":true,"typeEnv":[{"name":"x.y","ident":{"type":{"primitive":"BOOL"}}},{"name":"y","ident":{"type":{"primitive":"BOOL"}}}],"container":"x","bindings":{"x.y":{"value":{"boolValue":true}},"y":{"value":{"boolValue":false}}},"value":{"boolValue":true}},"ast":"y^#*expr.Expr_IdentExpr#","checkedAst":"x.y~bool^x.y","type":"bool"}]}]},{"name":"optionals","suites":[{"name":"optionals","tests":[{"original":{"name":"null","expr":"optional.of(null).hasValue()","value":{"boolValue":true}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n null~null\n)~optional_type(null)^optional_of.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"null_non_zero_value","expr":"optional.ofNonZeroValue(null).hasValue()","value":{"boolValue":false}},"ast":"optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"optional.ofNonZeroValue(\n null~null\n)~optional_type(null)^optional_ofNonZeroValue.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"none_or_none_or_value","expr":"optional.none().or(optional.none()).orValue(42)","value":{"int64Value":"42"}},"ast":"optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.none()~optional_type(int)^optional_none.or(\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^optional_or_optional.orValue(\n 42~int\n)~int^optional_orValue_value","type":"int"},{"original":{"name":"none_optMap_hasValue","expr":"optional.none().optMap(y, y + 1).hasValue()","value":{"boolValue":false}},"ast":"optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n optional.none()~optional_type(dyn)^optional_none.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.none()~optional_type(int)^optional_none.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"empty_map_optFlatMap_hasValue","expr":"{}.?key.optFlatMap(k, k.?subkey).hasValue()","value":{"boolValue":false}},"error":"ERROR: empty_map_optFlatMap_hasValue:1:3: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ..^\nERROR: empty_map_optFlatMap_hasValue:1:24: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | .......................^"},{"original":{"name":"map_empty_submap_optFlatMap_hasValue","expr":"{'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()","value":{"boolValue":false}},"error":"ERROR: map_empty_submap_optFlatMap_hasValue:1:12: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ...........^\nERROR: map_empty_submap_optFlatMap_hasValue:1:33: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ................................^"},{"original":{"name":"map_null_entry_hasValue","expr":"{'null_key': dyn(null)}.?null_key.hasValue()","value":{"boolValue":true}},"error":"ERROR: map_null_entry_hasValue:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.hasValue()\n | .......................^"},{"original":{"name":"map_null_entry_no_such_key","expr":"{'null_key': dyn(null)}.?null_key.invalid.hasValue()","evalError":{"errors":[{"message":"no such key"}]}},"error":"ERROR: map_null_entry_no_such_key:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.invalid.hasValue()\n | .......................^"},{"original":{"name":"map_absent_key_absent_field_none","expr":"{true: dyn(0)}[?false].absent.hasValue()","value":{"boolValue":false}},"error":"ERROR: map_absent_key_absent_field_none:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?false].absent.hasValue()\n | ..............^"},{"original":{"name":"map_present_key_invalid_field","expr":"{true: dyn(0)}[?true].absent.hasValue()","evalError":{"errors":[{"message":"no such key"}]}},"error":"ERROR: map_present_key_invalid_field:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?true].absent.hasValue()\n | ..............^"},{"original":{"name":"map_undefined_entry_hasValue","expr":"{}.?null_key.invalid.hasValue()","value":{"boolValue":false}},"error":"ERROR: map_undefined_entry_hasValue:1:3: unsupported syntax '.?'\n | {}.?null_key.invalid.hasValue()\n | ..^"},{"original":{"name":"map_submap_subkey_optFlatMap_value","expr":"{'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()","value":{"stringValue":"subvalue"}},"error":"ERROR: map_submap_subkey_optFlatMap_value:1:32: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ...............................^\nERROR: map_submap_subkey_optFlatMap_value:1:53: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ....................................................^"},{"original":{"name":"map_submap_optFlatMap_value","expr":"{'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()","value":{"stringValue":""}},"error":"ERROR: map_submap_optFlatMap_value:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | .......................^\nERROR: map_submap_optFlatMap_value:1:45: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | ............................................^"},{"original":{"name":"map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue","expr":"{'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()","value":{"boolValue":false}},"error":"ERROR: map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()\n | .......................^"},{"original":{"name":"optional_of_optMap_value","expr":"optional.of(42).optMap(y, y + 1).value()","value":{"int64Value":"43"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.value()~int^optional_value","type":"int"},{"original":{"name":"optional_ofNonZeroValue_or_optional_value","expr":"optional.ofNonZeroValue(42).or(optional.of(20)).value() == 42","value":{"boolValue":true}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n 42^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.ofNonZeroValue(\n 42~int\n )~optional_type(int)^optional_ofNonZeroValue.or(\n optional.of(\n 20~int\n )~optional_type(int)^optional_of\n )~optional_type(int)^optional_or_optional.value()~int^optional_value,\n 42~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_optional_hasValue","expr":"(has({}.x) ? optional.of({}.x) : optional.none()).hasValue()","value":{"boolValue":false}},"ast":"_?_:_(\n {}^#*expr.Expr_StructExpr#.x~test-only~^#*expr.Expr_SelectExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n {}^#*expr.Expr_StructExpr#.x^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n {}~map(dyn, dyn).x~test-only~~bool,\n optional.of(\n {}~map(dyn, dyn).x~dyn\n )~optional_type(dyn)^optional_of,\n optional.none()~optional_type(dyn)^optional_none\n)~optional_type(dyn)^conditional.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"map_optindex_hasValue","expr":"{}.?x.hasValue()","value":{"boolValue":false}},"error":"ERROR: map_optindex_hasValue:1:3: unsupported syntax '.?'\n | {}.?x.hasValue()\n | ..^"},{"original":{"name":"has_map_optindex","expr":"has({}.?x.y)","value":{"boolValue":false}},"error":"ERROR: has_map_optindex:1:7: unsupported syntax '.?'\n | has({}.?x.y)\n | ......^"},{"original":{"name":"has_map_optindex_field","expr":"has({'x': {'y': 'z'}}.?x.y)","value":{"boolValue":true}},"error":"ERROR: has_map_optindex_field:1:22: unsupported syntax '.?'\n | has({'x': {'y': 'z'}}.?x.y)\n | .....................^"},{"original":{"name":"type","expr":"type(optional.none()) == optional_type","value":{"boolValue":true}},"ast":"_==_(\n type(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional_type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n optional.none()~optional_type(dyn)^optional_none\n )~type(optional_type(dyn))^type,\n optional_type~type(optional_type)^optional_type\n)~bool^equals","type":"bool"},{"original":{"name":"optional_chaining_1","expr":"optional.ofNonZeroValue('').or(optional.of({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])).orValue('default value')","value":{"stringValue":"goodbye"}},"ast":"optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n _[_](\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"dashed-index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n \"dashed-index\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.ofNonZeroValue(\n \"\"~string\n)~optional_type(string)^optional_ofNonZeroValue.or(\n optional.of(\n _[_](\n {\n \"c\"~string:{\n \"dashed-index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n \"dashed-index\"~string\n )~string^index_map\n )~optional_type(string)^optional_of\n)~optional_type(string)^optional_or_optional.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_2","expr":"{'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')","value":{"stringValue":"goodbye"}},"error":"ERROR: optional_chaining_2:1:37: unsupported syntax '[?'\n | {'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')\n | ....................................^"},{"original":{"name":"optional_chaining_3","expr":"{'c': {}}.c[?'missing-index'].orValue('default value')","value":{"stringValue":"default value"}},"error":"ERROR: optional_chaining_3:1:12: unsupported syntax '[?'\n | {'c': {}}.c[?'missing-index'].orValue('default value')\n | ...........^"},{"original":{"name":"optional_chaining_4","expr":"optional.of({'c': {'index': 'goodbye'}}).c.index.orValue('default value')","value":{"stringValue":"goodbye"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.index^#*expr.Expr_SelectExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n {\n \"c\"~string:{\n \"index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n)~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).index~optional_type(string).orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_5","expr":"optional.of({'c': {}}).c.missing.or(optional.none()[0]).orValue('default value')","value":{"stringValue":"default value"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n {\n \"c\"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.none()~optional_type(list(string))^optional_none,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_6","expr":"optional.of({'c': {}}).c.missing.or(optional.of(['list-value'])[0]).orValue('default value')","value":{"stringValue":"list-value"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.of(\n [\n \"list-value\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n {\n \"c\"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.of(\n [\n \"list-value\"~string\n ]~list(string)\n )~optional_type(list(string))^optional_of,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_7","expr":"optional.of({'c': {'index': 'goodbye'}}).c['index'].orValue('default value')","value":{"stringValue":"goodbye"}},"ast":"_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n \"index\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n optional.of(\n {\n \"c\"~string:{\n \"index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n \"index\"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_8","expr":"optional.of({'c': {}}).c['missing'].orValue('default value')","value":{"stringValue":"default value"}},"ast":"_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n \"missing\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n optional.of(\n {\n \"c\"~string:{}~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n \"missing\"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_9","expr":"has(optional.of({'c': {'entry': 'hello world'}}).c) \u0026\u0026 !has(optional.of({'c': {'entry': 'hello world'}}).c.missing)","value":{"boolValue":true}},"ast":"_\u0026\u0026_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"entry\"^#*expr.Constant_StringValue#:\"hello world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c~test-only~^#*expr.Expr_SelectExpr#,\n !_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"entry\"^#*expr.Constant_StringValue#:\"hello world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing~test-only~^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n optional.of(\n {\n \"c\"~string:{\n \"entry\"~string:\"hello world\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~test-only~~bool,\n !_(\n optional.of(\n {\n \"c\"~string:{\n \"entry\"~string:\"hello world\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).missing~test-only~~bool\n )~bool^logical_not\n)~bool^logical_and","type":"bool"},{"original":{"name":"optional_chaining_10","expr":"optional.ofNonZeroValue({'c': {'dashed-index': 'goodbye'}}.a.z).orValue({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])","evalError":{"errors":[{"message":"no such key"}]}},"ast":"optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"dashed-index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.a^#*expr.Expr_SelectExpr#.z^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n _[_](\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"dashed-index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n \"dashed-index\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.ofNonZeroValue(\n {\n \"c\"~string:{\n \"dashed-index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string)).a~map(string, string).z~string\n)~optional_type(string)^optional_ofNonZeroValue.orValue(\n _[_](\n {\n \"c\"~string:{\n \"dashed-index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n \"dashed-index\"~string\n )~string^index_map\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_11","expr":"{'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()","value":{"int64Value":"7"}},"error":"ERROR: optional_chaining_11:1:35: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ..................................^\nERROR: optional_chaining_11:1:84: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ...................................................................................^"},{"original":{"name":"optional_chaining_12","expr":"{?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}","value":{"mapValue":{"entries":[{"key":{"stringValue":"nested_map"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"map"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"dashed-index"},"value":{"stringValue":"goodbye"}}]}}}]}}}]}}},"error":"ERROR: optional_chaining_12:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}\n | .^"},{"original":{"name":"optional_chaining_13","expr":"{?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}","value":{"mapValue":{"entries":[{"key":{"stringValue":"singleton"},"value":{"boolValue":true}}]}}},"error":"ERROR: optional_chaining_13:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}\n | .^"},{"original":{"name":"optional_chaining_14","expr":"[?{}.?c, ?optional.of(42), ?optional.none()]","value":{"listValue":{"values":[{"int64Value":"42"}]}}},"error":"ERROR: optional_chaining_14:1:2: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .^\nERROR: optional_chaining_14:1:5: unsupported syntax '.?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ....^\nERROR: optional_chaining_14:1:10: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .........^\nERROR: optional_chaining_14:1:28: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ...........................^"},{"original":{"name":"optional_chaining_15","expr":"[?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]","value":{"listValue":{}}},"error":"ERROR: optional_chaining_15:1:2: unsupported syntax '?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | .^\nERROR: optional_chaining_15:1:36: unsupported syntax '.?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | ...................................^"},{"original":{"name":"optional_chaining_16","expr":"optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_chaining_16:1:26: unsupported syntax '?'\n | optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()\n | .........................^"},{"original":{"name":"has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field","expr":"has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:18: unsupported syntax '?'\n | has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)\n | .................^"},{"original":{"name":"optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field","expr":"optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:38: unsupported syntax '?'\n | optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()\n | .....................................^"},{"original":{"name":"struct_map_optindex_field","expr":"TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"error":"ERROR: struct_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string\n | .............^"},{"original":{"name":"struct_optional_ofNonZeroValue_map_optindex_field","expr":"TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"error":"ERROR: struct_optional_ofNonZeroValue_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string\n | .............^"},{"original":{"name":"struct_map_optindex_field_nested","expr":"TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{"entries":[{"key":{"stringValue":"hello"},"value":{"stringValue":"world"}}]}}},"error":"ERROR: struct_map_optindex_field_nested:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string\n | .............^"},{"original":{"name":"struct_list_optindex_field","expr":"TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"greetings"},{"stringValue":"world"}]}}},"error":"ERROR: struct_list_optindex_field:1:45: unsupported syntax '?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ............................................^\nERROR: struct_list_optindex_field:1:83: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ..................................................................................^"},{"original":{"name":"optional_empty_map_optindex_hasValue","expr":"optional.of({}).?c.hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_empty_map_optindex_hasValue:1:16: unsupported syntax '.?'\n | optional.of({}).?c.hasValue()\n | ...............^"},{"original":{"name":"empty_struct_optindex_hasValue","expr":"TestAllTypes{}.?repeated_string.hasValue()","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: empty_struct_optindex_hasValue:1:15: unsupported syntax '.?'\n | TestAllTypes{}.?repeated_string.hasValue()\n | ..............^"},{"original":{"name":"optional_empty_struct_optindex_hasValue","expr":"optional.of(TestAllTypes{}).?repeated_string.hasValue()","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: optional_empty_struct_optindex_hasValue:1:28: unsupported syntax '.?'\n | optional.of(TestAllTypes{}).?repeated_string.hasValue()\n | ...........................^"},{"original":{"name":"optional_none_optselect_hasValue","expr":"optional.none().?repeated_string.hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_none_optselect_hasValue:1:16: unsupported syntax '.?'\n | optional.none().?repeated_string.hasValue()\n | ...............^"},{"original":{"name":"struct_optindex_value","expr":"TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"foo"}]}}},"error":"ERROR: struct_optindex_value:1:39: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()\n | ......................................^"},{"original":{"name":"optional_struct_optindex_value","expr":"optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"foo"}]}}},"error":"ERROR: optional_struct_optindex_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()\n | ...................................................^"},{"original":{"name":"optional_struct_optindex_index_value","expr":"optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()","container":"cel.expr.conformance.proto2","value":{"stringValue":"foo"}},"error":"ERROR: optional_struct_optindex_index_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()\n | ...................................................^"},{"original":{"name":"empty_list_optindex_hasValue","expr":"[][?0].hasValue()","value":{"boolValue":false}},"error":"ERROR: empty_list_optindex_hasValue:1:3: unsupported syntax '[?'\n | [][?0].hasValue()\n | ..^"},{"original":{"name":"optional_empty_list_optindex_hasValue","expr":"optional.of([])[?0].hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_empty_list_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.of([])[?0].hasValue()\n | ...............^"},{"original":{"name":"optional_none_optindex_hasValue","expr":"optional.none()[?0].hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_none_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.none()[?0].hasValue()\n | ...............^"},{"original":{"name":"list_optindex_value","expr":"['foo'][?0].value()","value":{"stringValue":"foo"}},"error":"ERROR: list_optindex_value:1:8: unsupported syntax '[?'\n | ['foo'][?0].value()\n | .......^"},{"original":{"name":"optional_list_optindex_value","expr":"optional.of(['foo'])[?0].value()","value":{"stringValue":"foo"}},"error":"ERROR: optional_list_optindex_value:1:21: unsupported syntax '[?'\n | optional.of(['foo'])[?0].value()\n | ....................^"},{"original":{"name":"map_key_mixed_type_optindex_value","expr":"{true: 1, 2: 2, 5u: 3}[?true].value()","value":{"int64Value":"1"}},"error":"ERROR: map_key_mixed_type_optindex_value:1:23: unsupported syntax '[?'\n | {true: 1, 2: 2, 5u: 3}[?true].value()\n | ......................^"},{"original":{"name":"map_key_mixed_numbers_double_key_optindex_value","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()","value":{"doubleValue":3}},"error":"ERROR: map_key_mixed_numbers_double_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()\n | ..........................^"},{"original":{"name":"map_key_mixed_numbers_uint_key_optindex_value","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()","value":{"doubleValue":2}},"error":"ERROR: map_key_mixed_numbers_uint_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()\n | ..........................^"},{"original":{"name":"map_key_mixed_numbers_int_key_optindex_value","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()","value":{"doubleValue":1}},"error":"ERROR: map_key_mixed_numbers_int_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()\n | ..........................^"},{"original":{"name":"optional_eq_none_none","expr":"optional.none() == optional.none()","value":{"boolValue":true}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^equals","type":"bool"},{"original":{"name":"optional_eq_none_int","expr":"optional.none() == optional.of(1)","value":{"boolValue":false}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals","type":"bool"},{"original":{"name":"optional_eq_int_none","expr":"optional.of(1) == optional.none()","value":{"boolValue":false}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^equals","type":"bool"},{"original":{"name":"optional_eq_int_int","expr":"optional.of(1) == optional.of(1)","value":{"boolValue":true}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals","type":"bool"},{"original":{"name":"optional_ne_none_none","expr":"optional.none() != optional.none()","value":{"boolValue":false}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^not_equals","type":"bool"},{"original":{"name":"optional_ne_none_int","expr":"optional.none() != optional.of(1)","value":{"boolValue":true}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals","type":"bool"},{"original":{"name":"optional_ne_int_none","expr":"optional.of(1) != optional.none()","value":{"boolValue":true}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^not_equals","type":"bool"},{"original":{"name":"optional_ne_int_int","expr":"optional.of(1) != optional.of(1)","value":{"boolValue":false}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals","type":"bool"},{"original":{"name":"map_optional_has","expr":"has({'foo': optional.none()}.foo)","value":{"boolValue":true}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"foo\"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~test-only~~bool","type":"bool"},{"original":{"name":"map_optional_select_has","expr":"has({'foo': optional.none()}.foo.bar)","value":{"boolValue":false}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo^#*expr.Expr_SelectExpr#.bar~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"foo\"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~optional_type(dyn).bar~test-only~~bool","type":"bool"},{"original":{"name":"map_optional_entry_has","expr":"has({?'foo': optional.none()}.foo)","value":{"boolValue":false}},"error":"ERROR: map_optional_entry_has:1:6: unsupported syntax '?'\n | has({?'foo': optional.none()}.foo)\n | .....^"}]}]},{"name":"parse","suites":[{"name":"nest","tests":[{"original":{"name":"list_index","description":"Member = Member '[' Expr ']'. Nested indices are supported up to 12 times.","expr":"a[a[a[a[a[a[a[a[a[a[a[a[0]]]]]]]]]]]]","typeEnv":[{"name":"a","ident":{"type":{"listType":{"elemType":{"primitive":"INT64"}}}}}],"bindings":{"a":{"value":{"listValue":{"values":[{"int64Value":"0"}]}}}},"value":{"int64Value":"0"}},"ast":"_[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n 0~int\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n)~int^index_list","type":"int"},{"original":{"name":"message_literal","description":"Member = Member '{' [FieldInits] '}'. Nested messages supported up to 12 levels deep.","expr":"NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{payload: TestAllTypes{single_int64: 137}}}}}}}}}}}}.payload.single_int64","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n payload:TestAllTypes{\n single_int64:137^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.payload^#*expr.Expr_SelectExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n payload:cel.expr.conformance.proto3.TestAllTypes{\n single_int64:137~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int64~int","type":"int"},{"original":{"name":"funcall","description":"Primary = ['.'] IDENT ['(' [ExprList] ')']. Nested function calls supported up to 12 levels deep.","expr":"int(uint(int(uint(int(uint(int(uint(int(uint(int(uint(7))))))))))))","value":{"int64Value":"7"}},"ast":"int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7~int\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"list_literal","description":"Primary = '[' [ExprList] ']'. Nested list literals up to 12 levels deep.","expr":"size([[[[[[[[[[[[0]]]]]]]]]]]])","value":{"int64Value":"1"}},"ast":"size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0~int\n ]~list(int)\n ]~list(list(int))\n ]~list(list(list(int)))\n ]~list(list(list(list(int))))\n ]~list(list(list(list(list(int)))))\n ]~list(list(list(list(list(list(int))))))\n ]~list(list(list(list(list(list(list(int)))))))\n ]~list(list(list(list(list(list(list(list(int))))))))\n ]~list(list(list(list(list(list(list(list(list(int)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(int))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(int)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(int))))))))))))\n)~int^size_list","type":"int"},{"original":{"name":"map_literal","description":"Primary = '{' [MapInits] '}'. Nested map literals up to 12 levels deep.","expr":"size({0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: 'foo'}}}}}}}}}}}})","value":{"int64Value":"1"}},"ast":"size(\n {\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n {\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:\"foo\"~string\n }~map(int, string)\n }~map(int, map(int, string))\n }~map(int, map(int, map(int, string)))\n }~map(int, map(int, map(int, map(int, string))))\n }~map(int, map(int, map(int, map(int, map(int, string)))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, string))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))))\n)~int^size_map","type":"int"},{"original":{"name":"parens","description":"Primary = '(' Expr ')'","expr":"((((((((((((((((((((((((((((((((7))))))))))))))))))))))))))))))))","value":{"int64Value":"7"}},"error":"ERROR: parens:-1:0: expression recursion limit exceeded: 32"}]},{"name":"repeat","tests":[{"original":{"name":"conditional","description":"Expr = ConditionalOr ['?' ConditionalOr ':' Expr]. Chained ternary operators up to 24 levels.","expr":"true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : false","value":{"boolValue":true}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n false~bool\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n)~bool^conditional","type":"bool"},{"original":{"name":"or","description":"ConditionalOr = [ConditionalOr '||'] ConditionalAnd. Logical OR statements with 32 conditions.","expr":"false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || true","value":{"boolValue":true}},"ast":"_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n true~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n)~bool^logical_or","type":"bool"},{"original":{"name":"and","description":"ConditionalAnd = [ConditionalAnd '\u0026\u0026'] Relation. Logical AND statements with 32 conditions.","expr":"true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n false~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n)~bool^logical_and","type":"bool"},{"original":{"name":"add_sub","description":"Addition = [Addition ('+' | '-')] Multiplication. Addition operators are supported up to 24 times consecutively.","expr":"3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3","value":{"int64Value":"3"}},"ast":"_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3~int,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n)~int^add_int64","type":"int"},{"original":{"name":"mul_div","description":"Multiplication = [Multiplication ('*' | '/' | '%')] Unary. Multiplication operators are supported up to 24 times consecutively.","expr":"4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4","value":{"int64Value":"4"}},"ast":"_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4~int,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n)~int^divide_int64","type":"int"},{"original":{"name":"not","description":"Unary = '!' {'!'} Member","expr":"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!true","value":{"boolValue":true}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"unary_neg","description":"Unary = '-' {'-'} Member","expr":"--------------------------------19","value":{"int64Value":"19"}},"ast":"19^#*expr.Constant_Int64Value#","checkedAst":"19~int","type":"int"},{"original":{"name":"select","description":"Member = Member '.' IDENT ['(' [ExprList] ')']. Selection is supported up to 12 times consecutively.","expr":"NestedTestAllTypes{}.child.child.child.child.child.child.child.child.child.child.payload.single_int32","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"NestedTestAllTypes{}^#*expr.Expr_StructExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.payload^#*expr.Expr_SelectExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.NestedTestAllTypes{}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int32~int","type":"int"},{"original":{"name":"index","description":"Member = Member '[' Expr ']'. Indexing is supported up to 12 times consecutively.","expr":"[[[[[[[[[[[['foo']]]]]]]]]]]][0][0][0][0][0][0][0][0][0][0][0][0]","value":{"stringValue":"foo"}},"ast":"_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n \"foo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n \"foo\"~string\n ]~list(string)\n ]~list(list(string))\n ]~list(list(list(string)))\n ]~list(list(list(list(string))))\n ]~list(list(list(list(list(string)))))\n ]~list(list(list(list(list(list(string))))))\n ]~list(list(list(list(list(list(list(string)))))))\n ]~list(list(list(list(list(list(list(list(string))))))))\n ]~list(list(list(list(list(list(list(list(list(string)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(string))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(string)))))))))))),\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(string))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(string)))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(string))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(string)))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(string))))))^index_list,\n 0~int\n )~list(list(list(list(list(string)))))^index_list,\n 0~int\n )~list(list(list(list(string))))^index_list,\n 0~int\n )~list(list(list(string)))^index_list,\n 0~int\n )~list(list(string))^index_list,\n 0~int\n )~list(string)^index_list,\n 0~int\n)~string^index_list","type":"string"},{"original":{"name":"list_literal","description":"Primary = '[' [ExprList] ']'. List literals with up to 32 elements.","expr":"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31][17]","value":{"int64Value":"17"}},"ast":"_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#,\n 11^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#,\n 14^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#,\n 16^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#,\n 18^#*expr.Constant_Int64Value#,\n 19^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#,\n 21^#*expr.Constant_Int64Value#,\n 22^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#,\n 24^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#,\n 26^#*expr.Constant_Int64Value#,\n 27^#*expr.Constant_Int64Value#,\n 28^#*expr.Constant_Int64Value#,\n 29^#*expr.Constant_Int64Value#,\n 30^#*expr.Constant_Int64Value#,\n 31^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int,\n 6~int,\n 7~int,\n 8~int,\n 9~int,\n 10~int,\n 11~int,\n 12~int,\n 13~int,\n 14~int,\n 15~int,\n 16~int,\n 17~int,\n 18~int,\n 19~int,\n 20~int,\n 21~int,\n 22~int,\n 23~int,\n 24~int,\n 25~int,\n 26~int,\n 27~int,\n 28~int,\n 29~int,\n 30~int,\n 31~int\n ]~list(int),\n 17~int\n)~int^index_list","type":"int"},{"original":{"name":"map_literal","description":"Primary = '{' [MapInits] '}'. Map literals with up to 32 entries.","expr":"{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine', 10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen', 14: 'fourteen', 15: 'fifteen', 16: 'sixteen', 17: 'seventeen', 18: 'eighteen', 19: 'nineteen', 20: 'twenty', 21: 'twenty-one', 22: 'twenty-two', 23: 'twenty-three', 24: 'twenty-four', 25: 'twenty-five', 26: 'twenty-six', 27: 'twenty-seven', 28: 'twenty-eight', 29: 'twenty-nine', 30: 'thirty', 31: 'thirty-one'}[17]","value":{"stringValue":"seventeen"}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:\"zero\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:\"one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:\"three\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 4^#*expr.Constant_Int64Value#:\"four\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:\"five\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:\"six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:\"seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:\"eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 9^#*expr.Constant_Int64Value#:\"nine\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 10^#*expr.Constant_Int64Value#:\"ten\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 11^#*expr.Constant_Int64Value#:\"eleven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 12^#*expr.Constant_Int64Value#:\"twelve\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 13^#*expr.Constant_Int64Value#:\"thirteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 14^#*expr.Constant_Int64Value#:\"fourteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 15^#*expr.Constant_Int64Value#:\"fifteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 16^#*expr.Constant_Int64Value#:\"sixteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 17^#*expr.Constant_Int64Value#:\"seventeen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 18^#*expr.Constant_Int64Value#:\"eighteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 19^#*expr.Constant_Int64Value#:\"nineteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 20^#*expr.Constant_Int64Value#:\"twenty\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 21^#*expr.Constant_Int64Value#:\"twenty-one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 22^#*expr.Constant_Int64Value#:\"twenty-two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 23^#*expr.Constant_Int64Value#:\"twenty-three\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 24^#*expr.Constant_Int64Value#:\"twenty-four\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 25^#*expr.Constant_Int64Value#:\"twenty-five\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 26^#*expr.Constant_Int64Value#:\"twenty-six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 27^#*expr.Constant_Int64Value#:\"twenty-seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 28^#*expr.Constant_Int64Value#:\"twenty-eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 29^#*expr.Constant_Int64Value#:\"twenty-nine\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 30^#*expr.Constant_Int64Value#:\"thirty\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 31^#*expr.Constant_Int64Value#:\"thirty-one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:\"zero\"~string,\n 1~int:\"one\"~string,\n 2~int:\"two\"~string,\n 3~int:\"three\"~string,\n 4~int:\"four\"~string,\n 5~int:\"five\"~string,\n 6~int:\"six\"~string,\n 7~int:\"seven\"~string,\n 8~int:\"eight\"~string,\n 9~int:\"nine\"~string,\n 10~int:\"ten\"~string,\n 11~int:\"eleven\"~string,\n 12~int:\"twelve\"~string,\n 13~int:\"thirteen\"~string,\n 14~int:\"fourteen\"~string,\n 15~int:\"fifteen\"~string,\n 16~int:\"sixteen\"~string,\n 17~int:\"seventeen\"~string,\n 18~int:\"eighteen\"~string,\n 19~int:\"nineteen\"~string,\n 20~int:\"twenty\"~string,\n 21~int:\"twenty-one\"~string,\n 22~int:\"twenty-two\"~string,\n 23~int:\"twenty-three\"~string,\n 24~int:\"twenty-four\"~string,\n 25~int:\"twenty-five\"~string,\n 26~int:\"twenty-six\"~string,\n 27~int:\"twenty-seven\"~string,\n 28~int:\"twenty-eight\"~string,\n 29~int:\"twenty-nine\"~string,\n 30~int:\"thirty\"~string,\n 31~int:\"thirty-one\"~string\n }~map(int, string),\n 17~int\n)~string^index_map","type":"string"},{"original":{"name":"message_literal","description":"Member = Member '{' [FieldInits] '}'. Message literals with up to 32 fields.","expr":"TestAllTypes{single_int32: 5, single_int64: 10, single_uint32: 15u, single_uint64: 20u, single_sint32: 25, single_sint64: 30, single_fixed32: 35u, single_fixed64: 40u, single_float: 45.0, single_double: 50.0, single_bool: true, single_string: 'sixty', single_bytes: b'sixty-five', single_value: 70.0, single_int64_wrapper: 75, single_int32_wrapper: 80, single_double_wrapper: 85.0, single_float_wrapper: 90.0, single_uint64_wrapper: 95u, single_uint32_wrapper: 100u, single_string_wrapper: 'one hundred five', single_bool_wrapper: true, repeated_int32: [115], repeated_int64: [120], repeated_uint32: [125u], repeated_uint64: [130u], repeated_sint32: [135], repeated_sint64: [140], repeated_fixed32: [145u], repeated_fixed64: [150u], repeated_sfixed32: [155], repeated_float: [160.0]}.single_sint64","container":"cel.expr.conformance.proto3","value":{"int64Value":"30"}},"ast":"TestAllTypes{\n single_int32:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int64:10^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32:15u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64:20u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint32:25^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint64:30^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed32:35u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed64:40u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_float:45^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_double:50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"sixty\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bytes:b\"sixty-five\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n single_value:70^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_int64_wrapper:75^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int32_wrapper:80^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_double_wrapper:85^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_float_wrapper:90^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64_wrapper:95u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32_wrapper:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string_wrapper:\"one hundred five\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int32:[\n 115^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int64:[\n 120^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint32:[\n 125u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint64:[\n 130u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint32:[\n 135^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint64:[\n 140^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed32:[\n 145u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed64:[\n 150u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sfixed32:[\n 155^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_float:[\n 160^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:5~int,\n single_int64:10~int,\n single_uint32:15u~uint,\n single_uint64:20u~uint,\n single_sint32:25~int,\n single_sint64:30~int,\n single_fixed32:35u~uint,\n single_fixed64:40u~uint,\n single_float:45~double,\n single_double:50~double,\n single_bool:true~bool,\n single_string:\"sixty\"~string,\n single_bytes:b\"sixty-five\"~bytes,\n single_value:70~double,\n single_int64_wrapper:75~int,\n single_int32_wrapper:80~int,\n single_double_wrapper:85~double,\n single_float_wrapper:90~double,\n single_uint64_wrapper:95u~uint,\n single_uint32_wrapper:100u~uint,\n single_string_wrapper:\"one hundred five\"~string,\n single_bool_wrapper:true~bool,\n repeated_int32:[\n 115~int\n ]~list(int),\n repeated_int64:[\n 120~int\n ]~list(int),\n repeated_uint32:[\n 125u~uint\n ]~list(uint),\n repeated_uint64:[\n 130u~uint\n ]~list(uint),\n repeated_sint32:[\n 135~int\n ]~list(int),\n repeated_sint64:[\n 140~int\n ]~list(int),\n repeated_fixed32:[\n 145u~uint\n ]~list(uint),\n repeated_fixed64:[\n 150u~uint\n ]~list(uint),\n repeated_sfixed32:[\n 155~int\n ]~list(int),\n repeated_float:[\n 160~double\n ]~list(double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_sint64~int","type":"int"}]},{"name":"string_literals","tests":[{"original":{"name":"single_quoted","expr":"'hello'","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"double_quoted","expr":"\"hello\"","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"triple_single_quoted","expr":"'''hello'''","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"triple_double_quoted","expr":"\"\"\"hello\"\"\"","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"single_quoted_escaped_punctuation","expr":"' \\\\ \\? \\\" \\' \\` '","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_punctuation","expr":"\" \\\\ \\? \\\" \\' \\` \"","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_punctuation","expr":"''' \\\\ \\? \\\" \\' \\` '''","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_punctuation","expr":"\"\"\" \\\\ \\? \\\" \\' \\` \"\"\"","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_punctuation","expr":"''' ? \" ' ` '''","value":{"stringValue":" ? \" ' ` "}},"ast":"\" ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_punctuation","expr":"\"\"\" ? \" ' ` \"\"\"","value":{"stringValue":" ? \" ' ` "}},"ast":"\" ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_special_control_characters","expr":"' \\a \\b \\f \\t \\v '","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_special_control_characters","expr":"\" \\a \\b \\f \\t \\v \"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"single_quoted_unescaped_special_control_characters","expr":"' \u0007 \b \f \t \u000b '","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"double_quoted_unescaped_special_control_characters","expr":"\" \u0007 \b \f \t \u000b \"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_special_control_characters","expr":"''' \\a \\b \\f \\t \\v '''","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_special_control_characters","expr":"\"\"\" \\a \\b \\f \\t \\v \"\"\"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_special_control_characters","expr":"''' \u0007 \b \f \t \u000b '''","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_special_control_characters","expr":"\"\"\" \u0007 \b \f \t \u000b \"\"\"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_line_feed","expr":"' \\n '","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_line_feed","expr":"\" \\n \"","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_line_feed","expr":"''' \\n '''","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_line_feed","expr":"\"\"\" \\n \"\"\"","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_line_feed","expr":"''' \n '''","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_line_feed","expr":"\"\"\" \n \"\"\"","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_carriage_return","expr":"' \\r '","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_carriage_return","expr":"\" \\r \"","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_carriage_return","expr":"''' \\r '''","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_carriage_return","expr":"\"\"\" \\r \"\"\"","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_windows_line_end","expr":"' \\r\\n '","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_windows_line_end","expr":"\" \\r\\n \"","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_windows_line_end","expr":"''' \\r\\n '''","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_windows_line_end","expr":"\"\"\" \\r\\n \"\"\"","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_all_control_characters","expr":"' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_all_control_characters","expr":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_unescaped_all_control_characters","expr":"' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_unescaped_all_control_characters","expr":"\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_all_control_characters","expr":"''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_all_control_characters","expr":"\"\"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"\"\"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_all_control_characters","expr":"''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_all_control_characters","expr":"\"\"\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"\"\"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_octal_escapes","expr":"' \\000 \\012 \\177 '","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_octal_escapes","expr":"\" \\000 \\012 \\177 \"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_octal_escapes","expr":"''' \\000 \\012 \\177 '''","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_octal_escapes","expr":"\"\"\" \\000 \\012 \\177 \"\"\"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_lower_x_escapes","expr":"' \\x00 \\x0A \\x7F '","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_lower_x_escapes","expr":"\" \\x00 \\x0A \\x7F \"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_lower_x_escapes","expr":"''' \\x00 \\x0A \\x7F '''","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_lower_x_escapes","expr":"\"\"\" \\x00 \\x0A \\x7F \"\"\"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_upper_x_escapes","expr":"' \\X00 \\X0A \\X7F '","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_upper_x_escapes","expr":"\" \\X00 \\X0A \\X7F \"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_upper_x_escapes","expr":"''' \\X00 \\X0A \\X7F '''","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_upper_x_escapes","expr":"\"\"\" \\X00 \\X0A \\X7F \"\"\"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_lower_u_escapes","expr":"' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"double_quoted_lower_u_escapes","expr":"\" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB \"","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"triple_single_quoted_lower_u_escapes","expr":"''' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '''","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"triple_double_quoted_lower_u_escapes","expr":"\"\"\" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB \"\"\"","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"single_quoted_upper_u_escapes","expr":"' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"double_quoted_upper_u_escapes","expr":"\" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C \"","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"triple_single_quoted_upper_u_escapes","expr":"''' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '''","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"triple_double_quoted_upper_u_escapes","expr":"\"\"\" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C \"\"\"","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"mixed_case_hex_single_quoted_escapes","expr":"' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"mixed_case_hex_double_quoted_escapes","expr":"\" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB \"","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"mixed_case_hex_triple_single_quoted_escapes","expr":"''' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '''","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"mixed_case_hex_triple_double_quoted_escapes","expr":"\"\"\" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB \"\"\"","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"unassigned_code_point_single_quoted_escapes","expr":"' \\U00088888 '","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_double_quoted_escapes","expr":"\" \\U00088888 \"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_single_quoted_escapes","expr":"''' \\U00088888 '''","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_double_quoted_escapes","expr":"\"\"\" \\U00088888 \"\"\"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_single_quoted_unescaped","expr":"' 򈢈 '","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_double_quoted_unescaped","expr":"\" 򈢈 \"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_single_quoted_unescaped","expr":"''' 򈢈 '''","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_double_quoted_unescaped","expr":"\"\"\" 򈢈 \"\"\"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"raw_single_quoted_escapes","expr":"r' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"stringValue":" \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"raw_double_quoted_escapes","expr":"r\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"stringValue":" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"raw_triple_single_quoted_escapes","expr":"r''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"raw_triple_double_quoted_escapes","expr":"r\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_single_quoted_escapes","expr":"R' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"stringValue":" \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_double_quoted_escapes","expr":"R\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"stringValue":" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_triple_single_quoted_escapes","expr":"R''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_triple_double_quoted_escapes","expr":"R\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"}]},{"name":"bytes_literals","tests":[{"original":{"name":"single_quoted","expr":"b'hello'","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"double_quoted","expr":"b\"hello\"","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted","expr":"b'''hello'''","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted","expr":"b\"\"\"hello\"\"\"","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_punctuation","expr":"b' \\\\ \\? \\\" \\' \\` '","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_punctuation","expr":"b\" \\\\ \\? \\\" \\' \\` \"","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_punctuation","expr":"b''' \\\\ \\? \\\" \\' \\` '''","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_punctuation","expr":"b\"\"\" \\\\ \\? \\\" \\' \\` \"\"\"","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_punctuation","expr":"b''' ? \" ' ` '''","value":{"bytesValue":"ID8gIiAnIGAg"}},"ast":"b\" ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_punctuation","expr":"b\"\"\" ? \" ' ` \"\"\"","value":{"bytesValue":"ID8gIiAnIGAg"}},"ast":"b\" ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_special_control_characters","expr":"b' \\a \\b \\f \\t \\v '","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_special_control_characters","expr":"b\" \\a \\b \\f \\t \\v \"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_unescaped_special_control_characters","expr":"b' \u0007 \b \f \t \u000b '","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_unescaped_special_control_characters","expr":"b\" \u0007 \b \f \t \u000b \"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_special_control_characters","expr":"b''' \\a \\b \\f \\t \\v '''","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_special_control_characters","expr":"b\"\"\" \\a \\b \\f \\t \\v \"\"\"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_special_control_characters","expr":"b''' \u0007 \b \f \t \u000b '''","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_special_control_characters","expr":"b\"\"\" \u0007 \b \f \t \u000b \"\"\"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_line_feed","expr":"b' \\n '","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_line_feed","expr":"b\" \\n \"","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_line_feed","expr":"b''' \\n '''","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_line_feed","expr":"b\"\"\" \\n \"\"\"","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_line_feed","expr":"b''' \n '''","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_line_feed","expr":"b\"\"\" \n \"\"\"","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_carriage_return","expr":"b' \\r '","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_carriage_return","expr":"b\" \\r \"","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_carriage_return","expr":"b''' \\r '''","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_carriage_return","expr":"b\"\"\" \\r \"\"\"","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_windows_line_end","expr":"b' \\r\\n '","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_windows_line_end","expr":"b\" \\r\\n \"","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_windows_line_end","expr":"b''' \\r\\n '''","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_windows_line_end","expr":"b\"\"\" \\r\\n \"\"\"","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_all_control_characters","expr":"b' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_all_control_characters","expr":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_unescaped_all_control_characters","expr":"b' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_unescaped_all_control_characters","expr":"b\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_all_control_characters","expr":"b''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_all_control_characters","expr":"b\"\"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"\"\"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_all_control_characters","expr":"b''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_all_control_characters","expr":"b\"\"\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"\"\"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_octal_escapes","expr":"b' \\000 \\012 \\177 \\377 '","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_octal_escapes","expr":"b\" \\000 \\012 \\177 \\377 \"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_octal_escapes","expr":"b''' \\000 \\012 \\177 \\377 '''","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_octal_escapes","expr":"b\"\"\" \\000 \\012 \\177 \\377 \"\"\"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_lower_x_escapes","expr":"b' \\x00 \\x0A \\x7F \\xFF '","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_lower_x_escapes","expr":"b\" \\x00 \\x0A \\x7F \\xFF \"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_lower_x_escapes","expr":"b''' \\x00 \\x0A \\x7F \\xFF '''","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_lower_x_escapes","expr":"b\"\"\" \\x00 \\x0A \\x7F \\xFF \"\"\"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_upper_x_escapes","expr":"b' \\X00 \\X0A \\X7F \\XFF '","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_upper_x_escapes","expr":"b\" \\X00 \\X0A \\X7F \\XFF \"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_upper_x_escapes","expr":"b''' \\X00 \\X0A \\X7F \\XFF '''","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_upper_x_escapes","expr":"b\"\"\" \\X00 \\X0A \\X7F \\XFF \"\"\"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_single_quoted_escapes","expr":"B' \\x4a \\x4B \\X4c \\X4D '","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_double_quoted_escapes","expr":"B\" \\x4a \\x4B \\X4c \\X4D \"","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_triple_single_quoted_escapes","expr":"B''' \\x4a \\x4B \\X4c \\X4D '''","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_triple_double_quoted_escapes","expr":"B\"\"\" \\x4a \\x4B \\X4c \\X4D \"\"\"","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"raw_single_quoted_escapes","expr":"br' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"bytesValue":"IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"raw_double_quoted_escapes","expr":"br\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"bytesValue":"IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"raw_triple_single_quoted_escapes","expr":"br''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"raw_triple_double_quoted_escapes","expr":"br\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_single_quoted_escapes","expr":"bR' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"bytesValue":"IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_double_quoted_escapes","expr":"bR\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"bytesValue":"IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_triple_single_quoted_escapes","expr":"bR''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_triple_double_quoted_escapes","expr":"bR\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"}]},{"name":"whitespace","tests":[{"original":{"name":"spaces","description":"Check that spaces are ignored.","expr":"[ . cel. expr .conformance. proto3. TestAllTypes { single_int64 : int ( 17 ) } . single_int64 ] [ 0 ] == ( 18 - 1 ) \u0026\u0026 ! false ? 1 : 2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"tabs","description":"Check that tabs (`\\t`) are ignored.","expr":"[\t.\tcel.\texpr\t.conformance.\tproto3.\tTestAllTypes\t{\tsingle_int64\t:\tint\t(\t17\t)\t}\t.\tsingle_int64\t]\t[\t0\t]\t==\t(\t18\t-\t1\t)\t\u0026\u0026\t!\tfalse\t?\t1\t:\t2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"new_lines","description":"Check that new lines (`\\n`) are ignored.","expr":"[\n.\ncel.\nexpr\n.conformance.\nproto3.\nTestAllTypes\n{\nsingle_int64\n:\nint\n(\n17\n)\n}\n.\nsingle_int64\n]\n[\n0\n]\n==\n(\n18\n-\n1\n)\n\u0026\u0026\n!\nfalse\n?\n1\n:\n2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"new_pages","description":"Check that new pages (`\\f`) are ignored.","expr":"[\f.\fcel.\fexpr\f.conformance.\fproto3.\fTestAllTypes\f{\fsingle_int64\f:\fint\f(\f17\f)\f}\f.\fsingle_int64\f]\f[\f0\f]\f==\f(\f18\f-\f1\f)\f\u0026\u0026\f!\ffalse\f?\f1\f:\f2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"carriage_returns","description":"Check that carriage returns (`\\r`) are ignored.","expr":"[\r.\rcel.\rexpr\r.conformance.\rproto3.\rTestAllTypes\r{\rsingle_int64\r:\rint\r(\r17\r)\r}\r.\rsingle_int64\r]\r[\r0\r]\r==\r(\r18\r-\r1\r)\r\u0026\u0026\r!\rfalse\r?\r1\r:\r2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"}]},{"name":"comments","tests":[{"original":{"name":"new_line_terminated","description":"Check that new-line-terminated comments are ignored.","expr":"[// @\n.// @\ncel.// @\nexpr// @\n.conformance.// @\nproto3.// @\nTestAllTypes// @\n{// @\nsingle_int64// @\n:// @\nint// @\n(// @\n17// @\n)// @\n}// @\n.// @\nsingle_int64// @\n]// @\n[// @\n0// @\n]// @\n==// @\n(// @\n18// @\n-// @\n1// @\n)// @\n\u0026\u0026// @\n!// @\nfalse// @\n?// @\n1// @\n:// @\n2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"}]},{"name":"selectors","tests":[{"original":{"name":"as","description":"Check that `as` can be used as a selector.","expr":"{ 'as': 1 }.as","value":{"int64Value":"1"}},"ast":"{\n \"as\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.as^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"as\"~string:1~int\n}~map(string, int).as~int","type":"int"},{"original":{"name":"break","description":"Check that `break` can be used as a selector.","expr":"{ 'break': 1 }.break","value":{"int64Value":"1"}},"ast":"{\n \"break\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.break^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"break\"~string:1~int\n}~map(string, int).break~int","type":"int"},{"original":{"name":"const","description":"Check that `const` can be used as a selector.","expr":"{ 'const': 1 }.const","value":{"int64Value":"1"}},"ast":"{\n \"const\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.const^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"const\"~string:1~int\n}~map(string, int).const~int","type":"int"},{"original":{"name":"continue","description":"Check that `continue` can be used as a selector.","expr":"{ 'continue': 1 }.continue","value":{"int64Value":"1"}},"ast":"{\n \"continue\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.continue^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"continue\"~string:1~int\n}~map(string, int).continue~int","type":"int"},{"original":{"name":"else","description":"Check that `else` can be used as a selector.","expr":"{ 'else': 1 }.else","value":{"int64Value":"1"}},"ast":"{\n \"else\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.else^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"else\"~string:1~int\n}~map(string, int).else~int","type":"int"},{"original":{"name":"for","description":"Check that `for` can be used as a selector.","expr":"{ 'for': 1 }.for","value":{"int64Value":"1"}},"ast":"{\n \"for\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.for^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"for\"~string:1~int\n}~map(string, int).for~int","type":"int"},{"original":{"name":"function","description":"Check that `function` can be used as a selector.","expr":"{ 'function': 1 }.function","value":{"int64Value":"1"}},"ast":"{\n \"function\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.function^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"function\"~string:1~int\n}~map(string, int).function~int","type":"int"},{"original":{"name":"if","description":"Check that `if` can be used as a selector.","expr":"{ 'if': 1 }.if","value":{"int64Value":"1"}},"ast":"{\n \"if\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.if^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"if\"~string:1~int\n}~map(string, int).if~int","type":"int"},{"original":{"name":"import","description":"Check that `import` can be used as a selector.","expr":"{ 'import': 1 }.import","value":{"int64Value":"1"}},"ast":"{\n \"import\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.import^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"import\"~string:1~int\n}~map(string, int).import~int","type":"int"},{"original":{"name":"let","description":"Check that `let` can be used as a selector.","expr":"{ 'let': 1 }.let","value":{"int64Value":"1"}},"ast":"{\n \"let\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.let^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"let\"~string:1~int\n}~map(string, int).let~int","type":"int"},{"original":{"name":"loop","description":"Check that `loop` can be used as a selector.","expr":"{ 'loop': 1 }.loop","value":{"int64Value":"1"}},"ast":"{\n \"loop\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.loop^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"loop\"~string:1~int\n}~map(string, int).loop~int","type":"int"},{"original":{"name":"package","description":"Check that `package` can be used as a selector.","expr":"{ 'package': 1 }.package","value":{"int64Value":"1"}},"ast":"{\n \"package\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.package^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"package\"~string:1~int\n}~map(string, int).package~int","type":"int"},{"original":{"name":"namespace","description":"Check that `namespace` can be used as a selector.","expr":"{ 'namespace': 1 }.namespace","value":{"int64Value":"1"}},"ast":"{\n \"namespace\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.namespace^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"namespace\"~string:1~int\n}~map(string, int).namespace~int","type":"int"},{"original":{"name":"return","description":"Check that `return` can be used as a selector.","expr":"{ 'return': 1 }.return","value":{"int64Value":"1"}},"ast":"{\n \"return\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.return^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"return\"~string:1~int\n}~map(string, int).return~int","type":"int"},{"original":{"name":"var","description":"Check that `var` can be used as a selector.","expr":"{ 'var': 1 }.var","value":{"int64Value":"1"}},"ast":"{\n \"var\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.var^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"var\"~string:1~int\n}~map(string, int).var~int","type":"int"},{"original":{"name":"void","description":"Check that `void` can be used as a selector.","expr":"{ 'void': 1 }.void","value":{"int64Value":"1"}},"ast":"{\n \"void\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.void^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"void\"~string:1~int\n}~map(string, int).void~int","type":"int"},{"original":{"name":"while","description":"Check that `while` can be used as a selector.","expr":"{ 'while': 1 }.while","value":{"int64Value":"1"}},"ast":"{\n \"while\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.while^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"while\"~string:1~int\n}~map(string, int).while~int","type":"int"}]},{"name":"receiver_function_names","tests":[{"original":{"name":"as","description":"Check that `as` can be used as a receiver function.","expr":"a.as() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.as()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.as() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'as' (in container '')\n | a.as() || true\n | ....^"},{"original":{"name":"break","description":"Check that `break` can be used as a receiver function.","expr":"a.break() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.break()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.break() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'break' (in container '')\n | a.break() || true\n | .......^"},{"original":{"name":"const","description":"Check that `const` can be used as a receiver function.","expr":"a.const() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.const()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.const() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'const' (in container '')\n | a.const() || true\n | .......^"},{"original":{"name":"continue","description":"Check that `continue` can be used as a receiver function.","expr":"a.continue() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.continue()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.continue() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'continue' (in container '')\n | a.continue() || true\n | ..........^"},{"original":{"name":"else","description":"Check that `else` can be used as a receiver function.","expr":"a.else() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.else()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.else() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'else' (in container '')\n | a.else() || true\n | ......^"},{"original":{"name":"for","description":"Check that `for` can be used as a receiver function.","expr":"a.for() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.for()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.for() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'for' (in container '')\n | a.for() || true\n | .....^"},{"original":{"name":"function","description":"Check that `function` can be used as a receiver function.","expr":"a.function() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.function()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.function() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'function' (in container '')\n | a.function() || true\n | ..........^"},{"original":{"name":"if","description":"Check that `if` can be used as a receiver function.","expr":"a.if() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.if()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.if() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'if' (in container '')\n | a.if() || true\n | ....^"},{"original":{"name":"import","description":"Check that `import` can be used as a receiver function.","expr":"a.import() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.import()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.import() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'import' (in container '')\n | a.import() || true\n | ........^"},{"original":{"name":"let","description":"Check that `let` can be used as a receiver function.","expr":"a.let() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.let()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.let() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'let' (in container '')\n | a.let() || true\n | .....^"},{"original":{"name":"loop","description":"Check that `loop` can be used as a receiver function.","expr":"a.loop() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.loop()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.loop() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'loop' (in container '')\n | a.loop() || true\n | ......^"},{"original":{"name":"package","description":"Check that `package` can be used as a receiver function.","expr":"a.package() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.package()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.package() || true\n | ^\nERROR: \u003cinput\u003e:1:10: undeclared reference to 'package' (in container '')\n | a.package() || true\n | .........^"},{"original":{"name":"namespace","description":"Check that `namespace` can be used as a receiver function.","expr":"a.namespace() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.namespace()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.namespace() || true\n | ^\nERROR: \u003cinput\u003e:1:12: undeclared reference to 'namespace' (in container '')\n | a.namespace() || true\n | ...........^"},{"original":{"name":"return","description":"Check that `return` can be used as a receiver function.","expr":"a.return() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.return()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.return() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'return' (in container '')\n | a.return() || true\n | ........^"},{"original":{"name":"var","description":"Check that `var` can be used as a receiver function.","expr":"a.var() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.var()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.var() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'var' (in container '')\n | a.var() || true\n | .....^"},{"original":{"name":"void","description":"Check that `void` can be used as a receiver function.","expr":"a.void() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.void()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.void() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'void' (in container '')\n | a.void() || true\n | ......^"},{"original":{"name":"while","description":"Check that `while` can be used as a receiver function.","expr":"a.while() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.while()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.while() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'while' (in container '')\n | a.while() || true\n | .......^"}]},{"name":"struct_field_names","tests":[{"original":{"name":"as","description":"Check that `as` can be used as a struct field name.","expr":"TestAllTypes{ as: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","as":true}}},"ast":"TestAllTypes{\n as:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n as:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"break","description":"Check that `break` can be used as a struct field name.","expr":"TestAllTypes{ break: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","break":true}}},"ast":"TestAllTypes{\n break:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n break:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"const","description":"Check that `const` can be used as a struct field name.","expr":"TestAllTypes{ const: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","const":true}}},"ast":"TestAllTypes{\n const:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n const:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"continue","description":"Check that `continue` can be used as a struct field name.","expr":"TestAllTypes{ continue: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","continue":true}}},"ast":"TestAllTypes{\n continue:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n continue:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"else","description":"Check that `else` can be used as a struct field name.","expr":"TestAllTypes{ else: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","else":true}}},"ast":"TestAllTypes{\n else:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n else:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"for","description":"Check that `for` can be used as a struct field name.","expr":"TestAllTypes{ for: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","for":true}}},"ast":"TestAllTypes{\n for:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n for:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"function","description":"Check that `function` can be used as a struct field name.","expr":"TestAllTypes{ function: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","function":true}}},"ast":"TestAllTypes{\n function:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n function:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"if","description":"Check that `if` can be used as a struct field name.","expr":"TestAllTypes{ if: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","if":true}}},"ast":"TestAllTypes{\n if:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n if:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"import","description":"Check that `import` can be used as a struct field name.","expr":"TestAllTypes{ import: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","import":true}}},"ast":"TestAllTypes{\n import:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n import:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"let","description":"Check that `let` can be used as a struct field name.","expr":"TestAllTypes{ let: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","let":true}}},"ast":"TestAllTypes{\n let:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n let:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"loop","description":"Check that `loop` can be used as a struct field name.","expr":"TestAllTypes{ loop: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","loop":true}}},"ast":"TestAllTypes{\n loop:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n loop:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"package","description":"Check that `package` can be used as a struct field name.","expr":"TestAllTypes{ package: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","package":true}}},"ast":"TestAllTypes{\n package:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n package:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"namespace","description":"Check that `namespace` can be used as a struct field name.","expr":"TestAllTypes{ namespace: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","namespace":true}}},"ast":"TestAllTypes{\n namespace:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n namespace:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"return","description":"Check that `return` can be used as a struct field name.","expr":"TestAllTypes{ return: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","return":true}}},"ast":"TestAllTypes{\n return:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n return:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"var","description":"Check that `var` can be used as a struct field name.","expr":"TestAllTypes{ var: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","var":true}}},"ast":"TestAllTypes{\n var:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n var:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"void","description":"Check that `void` can be used as a struct field name.","expr":"TestAllTypes{ void: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","void":true}}},"ast":"TestAllTypes{\n void:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n void:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"while","description":"Check that `while` can be used as a struct field name.","expr":"TestAllTypes{ while: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","while":true}}},"ast":"TestAllTypes{\n while:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n while:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]}]},{"name":"plumbing","suites":[{"name":"min","tests":[{"original":{"name":"min_program","description":"Smallest functionality: expr in, result out.","expr":"17","value":{"int64Value":"17"}},"ast":"17^#*expr.Constant_Int64Value#","checkedAst":"17~int","type":"int"}]},{"name":"eval_results","tests":[{"original":{"name":"error_result","description":"Check that error results go through.","expr":"1 / 0","evalError":{"errors":[{"message":"foo"}]}},"ast":"_/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 1~int,\n 0~int\n)~int^divide_int64","type":"int"},{"original":{"name":"eval_map_results","description":"Check that map literals results are order independent.","expr":"{\"k1\":\"v1\",\"k\":\"v\"}","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}},{"key":{"stringValue":"k1"},"value":{"stringValue":"v1"}}]}}},"ast":"{\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"{\n \"k1\"~string:\"v1\"~string,\n \"k\"~string:\"v\"~string\n}~map(string, string)","type":"map(string, string)"}]},{"name":"check_inputs","tests":[{"original":{"name":"skip_check","description":"Make sure we can skip type checking.","expr":"[17, 'pancakes']","disableCheck":true,"value":{"listValue":{"values":[{"int64Value":"17"},{"stringValue":"pancakes"}]}}},"ast":"[\n 17^#*expr.Constant_Int64Value#,\n \"pancakes\"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n 17~int,\n \"pancakes\"~string\n]~list(dyn)","type":"list(dyn)"}]},{"name":"eval_inputs","tests":[{"original":{"name":"one_ignored_value_arg","description":"Check that value bindings can be given, even if ignored.","expr":"'foo'","bindings":{"x":{"value":{"int64Value":"17"}}},"value":{"stringValue":"foo"}},"ast":"\"foo\"^#*expr.Constant_StringValue#","checkedAst":"\"foo\"~string","type":"string"}]}]},{"name":"proto2","suites":[{"name":"literal_singular","tests":[{"original":{"name":"int64_nocontainer","expr":"cel.expr.conformance.proto2.TestAllTypes{single_int64: 17}","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64":"17"}}},"ast":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int32","expr":"TestAllTypes{single_int32: -34}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":-34}}},"ast":"TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int32_eq_uint","expr":"Int32Value{value: 34} == dyn(UInt64Value{value: 34u})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_int32_eq_uint","expr":"Int32Value{value: 34} == dyn(UInt64Value{value: 18446744073709551615u})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"int32_eq_double","expr":"Int32Value{value: 34} == dyn(DoubleValue{value: 34.0})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_int32_eq_double","expr":"Int32Value{value: 34} == dyn(DoubleValue{value: -9223372036854775809.0})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:-9.223372036854776e+18^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:-9.223372036854776e+18~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"int64","expr":"TestAllTypes{single_int64: 17}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64":"17"}}},"ast":"TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint32","expr":"TestAllTypes{single_uint32: 1u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32":1}}},"ast":"TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint32_eq_int","expr":"UInt32Value{value: 34u} == dyn(Int64Value{value: 34})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_uint32_eq_int","expr":"UInt32Value{value: 34u} == dyn(Int64Value{value: -1})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"uint32_eq_double","expr":"UInt32Value{value: 34u} == dyn(DoubleValue{value: 34.0})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_uint32_eq_double","expr":"UInt32Value{value: 34u} == dyn(DoubleValue{value: 18446744073709551616.0})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:1.8446744073709552e+19^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:1.8446744073709552e+19~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"uint64","expr":"TestAllTypes{single_uint64: 9999u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64":"9999"}}},"ast":"TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sint32","expr":"TestAllTypes{single_sint32: -3}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSint32":-3}}},"ast":"TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sint64","expr":"TestAllTypes{single_sint64: 255}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSint64":"255"}}},"ast":"TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"fixed32","expr":"TestAllTypes{single_fixed32: 43u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFixed32":43}}},"ast":"TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"fixed64","expr":"TestAllTypes{single_fixed64: 1880u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFixed64":"1880"}}},"ast":"TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sfixed32","expr":"TestAllTypes{single_sfixed32: -404}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSfixed32":-404}}},"ast":"TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sfixed64","expr":"TestAllTypes{single_sfixed64: -1}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSfixed64":"-1"}}},"ast":"TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"float","expr":"TestAllTypes{single_float: 3.1416}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloat":3.1416}}},"ast":"TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"float_eq_int","expr":"FloatValue{value: 3.0} == dyn(Int64Value{value: 3})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n FloatValue{\n value:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:3~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:3~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_float_eq_int","expr":"FloatValue{value: -1.14} == dyn(Int64Value{value: -1})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n FloatValue{\n value:-1.14^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:-1.14~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"float_eq_uint","expr":"FloatValue{value: 34.0} == dyn(UInt64Value{value: 34u})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n FloatValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:34~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_float_eq_uint","expr":"FloatValue{value: -1.0} == dyn(UInt64Value{value: 18446744073709551615u})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n FloatValue{\n value:-1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:-1~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"double","expr":"TestAllTypes{single_double: 6.022e23}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDouble":6.022e+23}}},"ast":"TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bool","expr":"TestAllTypes{single_bool: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBool":true}}},"ast":"TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"string","expr":"TestAllTypes{single_string: 'foo'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleString":"foo"}}},"ast":"TestAllTypes{\n single_string:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string:\"foo\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bytes","expr":"TestAllTypes{single_bytes: b'\\377'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytes":"/w=="}}},"ast":"TestAllTypes{\n single_bytes:b\"\\xff\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes:b\"\\xff\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"}]},{"name":"literal_wellknown","tests":[{"original":{"name":"any","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 1}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":1}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"duration","expr":"TestAllTypes{single_duration: duration('123s')}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDuration":"123s"}}},"ast":"TestAllTypes{\n single_duration:duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_duration:duration(\n \"123s\"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"timestamp","expr":"TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleTimestamp":"2009-02-13T23:31:30Z"}}},"ast":"TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"struct","expr":"TestAllTypes{single_struct: {'one': 1, 'two': 2}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStruct":{"one":1,"two":2}}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n \"one\"~string:1~int,\n \"two\"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"value","expr":"TestAllTypes{single_value: 'foo'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":"foo"}}},"ast":"TestAllTypes{\n single_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"foo\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int64_wrapper","expr":"TestAllTypes{single_int64_wrapper: -321}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64Wrapper":"-321"}}},"ast":"TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int32_wrapper","expr":"TestAllTypes{single_int32_wrapper: -456}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":-456}}},"ast":"TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"double_wrapper","expr":"TestAllTypes{single_double_wrapper: 2.71828}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":2.71828}}},"ast":"TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"float_wrapper","expr":"TestAllTypes{single_float_wrapper: 2.99792e8}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":299792000}}},"ast":"TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint64_wrapper","expr":"TestAllTypes{single_uint64_wrapper: 8675309u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64Wrapper":"8675309"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint32_wrapper","expr":"TestAllTypes{single_uint32_wrapper: 987u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":987}}},"ast":"TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"string_wrapper","expr":"TestAllTypes{single_string_wrapper: 'hubba'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStringWrapper":"hubba"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"hubba\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:\"hubba\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bool_wrapper","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bytes_wrapper","expr":"TestAllTypes{single_bytes_wrapper: b'\\301\\103'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytesWrapper":"wUM="}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"}]},{"name":"singular_bind","tests":[{"original":{"name":"int32","expr":"x.single_int32","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":17}}}},"value":{"int64Value":"17"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto2.TestAllTypes^x.single_int32~int","type":"int"},{"original":{"name":"int64","expr":"x.single_int64","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64":"-99"}}}},"value":{"int64Value":"-99"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto2.TestAllTypes^x.single_int64~int","type":"int"}]},{"name":"empty_field","tests":[{"original":{"name":"scalar_with_default","expr":"TestAllTypes{}.single_int32","container":"cel.expr.conformance.proto2","value":{"int64Value":"-32"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~int","type":"int"},{"original":{"name":"scalar_no_default","expr":"TestAllTypes{}.single_fixed32","container":"cel.expr.conformance.proto2","value":{"uint64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_fixed32~uint","type":"uint"},{"original":{"name":"nested_message","expr":"TestAllTypes{}.single_nested_message","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes.NestedMessage"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage","type":"cel.expr.conformance.proto2.TestAllTypes.NestedMessage"},{"original":{"name":"nested_message_subfield","expr":"TestAllTypes{}.single_nested_message.bb","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage.bb~int","type":"int"},{"original":{"name":"wkt","expr":"TestAllTypes{}.single_int64_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"repeated_scalar","expr":"TestAllTypes{}.repeated_int64","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int64~list(int)","type":"list(int)"},{"original":{"name":"repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"repeated_nested","expr":"TestAllTypes{}.repeated_nested_message","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)","type":"list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)"},{"original":{"name":"map","expr":"TestAllTypes{}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~map(string, string)","type":"map(string, string)"}]},{"name":"has","tests":[{"original":{"name":"undefined","expr":"has(TestAllTypes{}.no_such_field)","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"no_such_field"}]}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^"},{"original":{"name":"repeated_none_implicit","expr":"has(TestAllTypes{}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_none_explicit","expr":"has(TestAllTypes{repeated_int32: []}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_one","expr":"has(TestAllTypes{repeated_int32: [1]}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_many","expr":"has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"map_none_implicit","expr":"has(TestAllTypes{}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_none_explicit","expr":"has(TestAllTypes{map_string_string: {}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one_default","expr":"has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"MT\"^#*expr.Constant_StringValue#:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n \"MT\"~string:\"\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one","expr":"has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_many","expr":"has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:\"dos\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string,\n \"two\"~string:\"dos\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"required","expr":"has(TestRequired{required_int32: 4}.required_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestRequired{\n required_int32:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.required_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestRequired{\n required_int32:4~int\n}~cel.expr.conformance.proto2.TestRequired^cel.expr.conformance.proto2.TestRequired.required_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_unset_no_default","expr":"has(TestAllTypes{}.single_sint32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool","type":"bool"},{"original":{"name":"optional_set_no_default","expr":"has(TestAllTypes{single_sint32: -4}.single_sint32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_sint32:-4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-4~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool","type":"bool"},{"original":{"name":"optional_unset_with_default","expr":"has(TestAllTypes{}.single_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_set_with_default","expr":"has(TestAllTypes{single_int32: 16}.single_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_set_to_default","expr":"has(TestAllTypes{single_int32: -32}.single_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_int32:-32^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-32~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_message_unset","expr":"has(TestAllTypes{}.standalone_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"optional_message_set","expr":"has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"optional_enum_unset","expr":"has(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"optional_enum_set","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"optional_enum_set_zero","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"oneof_unset","expr":"has(TestAllTypes{}.single_nested_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_other_set","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set","expr":"has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set_default","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_enum~test-only~~bool","type":"bool"}]},{"name":"set_null","tests":[{"original":{"name":"single_message","expr":"TestAllTypes{single_nested_message: null} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_any","expr":"TestAllTypes{single_any: null}.single_any","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"single_value","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"single_duration","expr":"TestAllTypes{single_duration: null} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_timestamp","expr":"TestAllTypes{single_timestamp: null} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_scalar","expr":"TestAllTypes{single_bool: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^"},{"original":{"name":"repeated","expr":"TestAllTypes{repeated_int32: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^"},{"original":{"name":"map","expr":"TestAllTypes{map_string_string: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^"},{"original":{"name":"list_value","expr":"TestAllTypes{list_value: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^"},{"original":{"name":"single_struct","expr":"TestAllTypes{single_struct: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^"}]},{"name":"quoted_fields","tests":[{"original":{"name":"set_field_with_quoted_name","expr":"TestAllTypes{`in`: true} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: set_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^"},{"original":{"name":"get_field_with_quoted_name","expr":"TestAllTypes{`in`: true}.`in`","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"error":"ERROR: get_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field_with_quoted_name:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^"}]},{"name":"extensions_has","tests":[{"original":{"name":"package_scoped_int32","expr":"has(msg.`cel.expr.conformance.proto2.int32_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"error":"ERROR: package_scoped_int32:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.int32_ext`)\n | ........^"},{"original":{"name":"package_scoped_nested_ext","expr":"has(msg.`cel.expr.conformance.proto2.nested_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"error":"ERROR: package_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_ext`)\n | ........^"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"error":"ERROR: package_scoped_test_all_types_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)\n | ........^"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: package_scoped_test_all_types_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)\n | ........^"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: package_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)\n | ........^"},{"original":{"name":"message_scoped_int64","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"error":"ERROR: message_scoped_int64:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)\n | ........^"},{"original":{"name":"message_scoped_nested_ext","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"error":"ERROR: message_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)\n | ........^"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: message_scoped_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)\n | ........^"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: message_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)\n | ........^"}]},{"name":"extensions_get","tests":[{"original":{"name":"package_scoped_int32","expr":"msg.`cel.expr.conformance.proto2.int32_ext` == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"error":"ERROR: package_scoped_int32:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.int32_ext` == 42\n | ....^"},{"original":{"name":"package_scoped_nested_ext","expr":"msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"error":"ERROR: package_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"error":"ERROR: package_scoped_test_all_types_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: package_scoped_test_all_types_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: package_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^"},{"original":{"name":"message_scoped_int64","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"error":"ERROR: message_scoped_int64:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42\n | ....^"},{"original":{"name":"message_scoped_nested_ext","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"error":"ERROR: message_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: message_scoped_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: message_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^"}]}]},{"name":"proto2_ext","suites":[{"name":"has_ext","tests":[{"original":{"name":"package_scoped_int32","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.int32_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_nested_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.nested_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.test_all_types_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.nested_enum_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.repeated_test_all_types)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_int64","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_nested_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~test-only~~bool","type":"bool"}]},{"name":"get_ext","tests":[{"original":{"name":"package_scoped_int32","expr":"proto.getExt(msg, cel.expr.conformance.proto2.int32_ext) == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~int,\n 42~int\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_nested_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.test_all_types_ext) == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"proto.getExt(msg, cel.expr.conformance.proto2.repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_int64","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext) == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~int,\n 42~int\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_nested_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals","type":"bool"}]}]},{"name":"proto3","suites":[{"name":"literal_singular","tests":[{"original":{"name":"int64_nocontainer","expr":"cel.expr.conformance.proto3.TestAllTypes{single_int64: 17}","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"17"}}},"ast":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int32","expr":"TestAllTypes{single_int32: -34}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":-34}}},"ast":"TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int64","expr":"TestAllTypes{single_int64: 17}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"17"}}},"ast":"TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint32","expr":"TestAllTypes{single_uint32: 1u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32":1}}},"ast":"TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint64","expr":"TestAllTypes{single_uint64: 9999u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64":"9999"}}},"ast":"TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sint32","expr":"TestAllTypes{single_sint32: -3}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSint32":-3}}},"ast":"TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sint64","expr":"TestAllTypes{single_sint64: 255}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSint64":"255"}}},"ast":"TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"fixed32","expr":"TestAllTypes{single_fixed32: 43u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFixed32":43}}},"ast":"TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"fixed64","expr":"TestAllTypes{single_fixed64: 1880u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFixed64":"1880"}}},"ast":"TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sfixed32","expr":"TestAllTypes{single_sfixed32: -404}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSfixed32":-404}}},"ast":"TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sfixed64","expr":"TestAllTypes{single_sfixed64: -1}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSfixed64":"-1"}}},"ast":"TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"float","expr":"TestAllTypes{single_float: 3.1416}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloat":3.1416}}},"ast":"TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"double","expr":"TestAllTypes{single_double: 6.022e23}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDouble":6.022e+23}}},"ast":"TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bool","expr":"TestAllTypes{single_bool: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBool":true}}},"ast":"TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"string","expr":"TestAllTypes{single_string: 'foo'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleString":"foo"}}},"ast":"TestAllTypes{\n single_string:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string:\"foo\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bytes","expr":"TestAllTypes{single_bytes: b'\\377'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytes":"/w=="}}},"ast":"TestAllTypes{\n single_bytes:b\"\\xff\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes:b\"\\xff\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"literal_wellknown","tests":[{"original":{"name":"any","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 1}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":1}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"duration","expr":"TestAllTypes{single_duration: duration('123s')}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDuration":"123s"}}},"ast":"TestAllTypes{\n single_duration:duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_duration:duration(\n \"123s\"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"timestamp","expr":"TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleTimestamp":"2009-02-13T23:31:30Z"}}},"ast":"TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"struct","expr":"TestAllTypes{single_struct: {'one': 1, 'two': 2}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStruct":{"one":1,"two":2}}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n \"one\"~string:1~int,\n \"two\"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"value","expr":"TestAllTypes{single_value: 'foo'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":"foo"}}},"ast":"TestAllTypes{\n single_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"foo\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int64_wrapper","expr":"TestAllTypes{single_int64_wrapper: -321}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64Wrapper":"-321"}}},"ast":"TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int32_wrapper","expr":"TestAllTypes{single_int32_wrapper: -456}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":-456}}},"ast":"TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"double_wrapper","expr":"TestAllTypes{single_double_wrapper: 2.71828}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":2.71828}}},"ast":"TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"float_wrapper","expr":"TestAllTypes{single_float_wrapper: 2.99792e8}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":299792000}}},"ast":"TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint64_wrapper","expr":"TestAllTypes{single_uint64_wrapper: 8675309u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64Wrapper":"8675309"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint32_wrapper","expr":"TestAllTypes{single_uint32_wrapper: 987u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":987}}},"ast":"TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"string_wrapper","expr":"TestAllTypes{single_string_wrapper: 'hubba'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStringWrapper":"hubba"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"hubba\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:\"hubba\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bool_wrapper","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bytes_wrapper","expr":"TestAllTypes{single_bytes_wrapper: b'\\301\\103'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytesWrapper":"wUM="}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"singular_bind","tests":[{"original":{"name":"int32","expr":"x.single_int32","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":17}}}},"value":{"int64Value":"17"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32~int","type":"int"},{"original":{"name":"int64","expr":"x.single_int64","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"-99"}}}},"value":{"int64Value":"-99"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64~int","type":"int"}]},{"name":"empty_field","tests":[{"original":{"name":"scalar","expr":"TestAllTypes{}.single_fixed32","container":"cel.expr.conformance.proto3","value":{"uint64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_fixed32~uint","type":"uint"},{"original":{"name":"nested_message","expr":"TestAllTypes{}.single_nested_message","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage","type":"cel.expr.conformance.proto3.TestAllTypes.NestedMessage"},{"original":{"name":"nested_message_subfield","expr":"TestAllTypes{}.single_nested_message.bb","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage.bb~int","type":"int"},{"original":{"name":"wkt","expr":"TestAllTypes{}.single_int64_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"repeated_scalar","expr":"TestAllTypes{}.repeated_int64","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)","type":"list(int)"},{"original":{"name":"repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"repeated_nested","expr":"TestAllTypes{}.repeated_nested_message","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)","type":"list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)"},{"original":{"name":"map","expr":"TestAllTypes{}.map_string_string","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~map(string, string)","type":"map(string, string)"}]},{"name":"has","tests":[{"original":{"name":"undefined","expr":"has(TestAllTypes{}.no_such_field)","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"no_such_field"}]}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^"},{"original":{"name":"repeated_none_implicit","expr":"has(TestAllTypes{}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_none_explicit","expr":"has(TestAllTypes{repeated_int32: []}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_one","expr":"has(TestAllTypes{repeated_int32: [1]}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_many","expr":"has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"map_none_implicit","expr":"has(TestAllTypes{}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_none_explicit","expr":"has(TestAllTypes{map_string_string: {}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one_default","expr":"has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"MT\"^#*expr.Constant_StringValue#:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n \"MT\"~string:\"\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one","expr":"has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_many","expr":"has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:\"dos\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string,\n \"two\"~string:\"dos\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"single_unset","expr":"has(TestAllTypes{}.single_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"single_set","expr":"has(TestAllTypes{single_int32: 16}.single_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"single_set_to_default","expr":"has(TestAllTypes{single_int32: 0}.single_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_int32:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"single_message_unset","expr":"has(TestAllTypes{}.standalone_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"single_message_set","expr":"has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{bb: 123}}.standalone_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{\n bb:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{\n bb:123~int\n }~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"single_message_set_to_default","expr":"has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"single_enum_unset","expr":"has(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"single_enum_set","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"single_enum_set_zero","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"oneof_unset","expr":"has(TestAllTypes{}.single_nested_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_other_set","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set","expr":"has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set_default","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_enum~test-only~~bool","type":"bool"}]},{"name":"set_null","tests":[{"original":{"name":"single_message","expr":"TestAllTypes{single_nested_message: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_any","expr":"TestAllTypes{single_any: null}.single_any","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"single_value","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"single_duration","expr":"TestAllTypes{single_duration: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_timestamp","expr":"TestAllTypes{single_timestamp: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_scalar","expr":"TestAllTypes{single_bool: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^"},{"original":{"name":"repeated","expr":"TestAllTypes{repeated_int32: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^"},{"original":{"name":"map","expr":"TestAllTypes{map_string_string: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^"},{"original":{"name":"list_value","expr":"TestAllTypes{list_value: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^"},{"original":{"name":"single_struct","expr":"TestAllTypes{single_struct: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^"}]},{"name":"quoted_fields","tests":[{"original":{"name":"set_field","expr":"TestAllTypes{`in`: true} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"error":"ERROR: set_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^"},{"original":{"name":"get_field","expr":"TestAllTypes{`in`: true}.`in`","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"error":"ERROR: get_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^"}]}]},{"name":"string","suites":[{"name":"size","tests":[{"original":{"name":"empty","expr":"size('')","value":{"int64Value":"0"}},"ast":"size(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"\"~string\n)~int^size_string","type":"int"},{"original":{"name":"one_ascii","expr":"size('A')","value":{"int64Value":"1"}},"ast":"size(\n \"A\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"A\"~string\n)~int^size_string","type":"int"},{"original":{"name":"one_unicode","expr":"size('ÿ')","value":{"int64Value":"1"}},"ast":"size(\n \"ÿ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"ÿ\"~string\n)~int^size_string","type":"int"},{"original":{"name":"ascii","expr":"size('four')","value":{"int64Value":"4"}},"ast":"size(\n \"four\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"four\"~string\n)~int^size_string","type":"int"},{"original":{"name":"unicode","expr":"size('πέντε')","value":{"int64Value":"5"}},"ast":"size(\n \"πέντε\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"πέντε\"~string\n)~int^size_string","type":"int"},{"original":{"name":"bytes_empty","expr":"size(b'')","value":{"int64Value":"0"}},"ast":"size(\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n b\"\"~bytes\n)~int^size_bytes","type":"int"},{"original":{"name":"bytes","expr":"size(b'abc')","value":{"int64Value":"3"}},"ast":"size(\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n b\"abc\"~bytes\n)~int^size_bytes","type":"int"}]},{"name":"starts_with","tests":[{"original":{"name":"basic_true","expr":"'foobar'.startsWith('foo')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.startsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.startsWith(\n \"foo\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"basic_false","expr":"'foobar'.startsWith('bar')","value":{"boolValue":false}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.startsWith(\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.startsWith(\n \"bar\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"empty_target","expr":"''.startsWith('foo')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.startsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.startsWith(\n \"foo\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"empty_arg","expr":"'foobar'.startsWith('')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.startsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.startsWith(\n \"\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.startsWith('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.startsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.startsWith(\n \"\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"unicode","expr":"'завтра'.startsWith('за')","value":{"boolValue":true}},"ast":"\"завтра\"^#*expr.Constant_StringValue#.startsWith(\n \"за\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"завтра\"~string.startsWith(\n \"за\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"unicode_smp","expr":"'🐱😀😛'.startsWith('🐱')","value":{"boolValue":true}},"ast":"\"🐱😀😛\"^#*expr.Constant_StringValue#.startsWith(\n \"🐱\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😛\"~string.startsWith(\n \"🐱\"~string\n)~bool^starts_with_string","type":"bool"}]},{"name":"ends_with","tests":[{"original":{"name":"basic_true","expr":"'foobar'.endsWith('bar')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.endsWith(\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.endsWith(\n \"bar\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"basic_false","expr":"'foobar'.endsWith('foo')","value":{"boolValue":false}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.endsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.endsWith(\n \"foo\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"empty_target","expr":"''.endsWith('foo')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.endsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.endsWith(\n \"foo\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"empty_arg","expr":"'foobar'.endsWith('')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.endsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.endsWith(\n \"\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.endsWith('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.endsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.endsWith(\n \"\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"unicode","expr":"'forté'.endsWith('té')","value":{"boolValue":true}},"ast":"\"forté\"^#*expr.Constant_StringValue#.endsWith(\n \"té\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"forté\"~string.endsWith(\n \"té\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"unicode_smp","expr":"'🐱😀😛'.endsWith('😛')","value":{"boolValue":true}},"ast":"\"🐱😀😛\"^#*expr.Constant_StringValue#.endsWith(\n \"😛\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😛\"~string.endsWith(\n \"😛\"~string\n)~bool^ends_with_string","type":"bool"}]},{"name":"matches","tests":[{"original":{"name":"basic","expr":"'hubba'.matches('ubb')","value":{"boolValue":true}},"ast":"\"hubba\"^#*expr.Constant_StringValue#.matches(\n \"ubb\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hubba\"~string.matches(\n \"ubb\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"empty_target","expr":"''.matches('foo|bar')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.matches(\n \"foo|bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.matches(\n \"foo|bar\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"empty_arg","expr":"'cows'.matches('')","value":{"boolValue":true}},"ast":"\"cows\"^#*expr.Constant_StringValue#.matches(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"cows\"~string.matches(\n \"\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.matches('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.matches(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.matches(\n \"\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"re_concat","expr":"'abcd'.matches('bc')","value":{"boolValue":true}},"ast":"\"abcd\"^#*expr.Constant_StringValue#.matches(\n \"bc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"abcd\"~string.matches(\n \"bc\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"re_alt","expr":"'grey'.matches('gr(a|e)y')","value":{"boolValue":true}},"ast":"\"grey\"^#*expr.Constant_StringValue#.matches(\n \"gr(a|e)y\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"grey\"~string.matches(\n \"gr(a|e)y\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"re_rep","expr":"'banana'.matches('ba(na)*')","value":{"boolValue":true}},"ast":"\"banana\"^#*expr.Constant_StringValue#.matches(\n \"ba(na)*\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"banana\"~string.matches(\n \"ba(na)*\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"unicode","expr":"'mañana'.matches('a+ñ+a+')","value":{"boolValue":true}},"ast":"\"mañana\"^#*expr.Constant_StringValue#.matches(\n \"a+ñ+a+\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"mañana\"~string.matches(\n \"a+ñ+a+\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"unicode_smp","expr":"'🐱😀😀'.matches('(a|😀){2}')","value":{"boolValue":true}},"ast":"\"🐱😀😀\"^#*expr.Constant_StringValue#.matches(\n \"(a|😀){2}\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😀\"~string.matches(\n \"(a|😀){2}\"~string\n)~bool^matches_string","type":"bool"}]},{"name":"concatenation","tests":[{"original":{"name":"concat_true","expr":"'he' + 'llo'","value":{"stringValue":"hello"}},"ast":"_+_(\n \"he\"^#*expr.Constant_StringValue#,\n \"llo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"he\"~string,\n \"llo\"~string\n)~string^add_string","type":"string"},{"original":{"name":"concat_with_spaces","expr":"'hello' + ' ' == 'hello'","value":{"boolValue":false}},"ast":"_==_(\n _+_(\n \"hello\"^#*expr.Constant_StringValue#,\n \" \"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"hello\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n \"hello\"~string,\n \" \"~string\n )~string^add_string,\n \"hello\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"concat_empty_string_beginning","expr":"'' + 'abc'","value":{"stringValue":"abc"}},"ast":"_+_(\n \"\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"\"~string,\n \"abc\"~string\n)~string^add_string","type":"string"},{"original":{"name":"concat_empty_string_end","expr":"'abc' + ''","value":{"stringValue":"abc"}},"ast":"_+_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"abc\"~string,\n \"\"~string\n)~string^add_string","type":"string"},{"original":{"name":"concat_empty_with_empty","expr":"'' + ''","value":{"stringValue":""}},"ast":"_+_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"\"~string,\n \"\"~string\n)~string^add_string","type":"string"},{"original":{"name":"unicode_unicode","expr":"'¢' + 'ÿ' + 'Ȁ'","value":{"stringValue":"¢ÿȀ"}},"ast":"_+_(\n _+_(\n \"¢\"^#*expr.Constant_StringValue#,\n \"ÿ\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"Ȁ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"¢\"~string,\n \"ÿ\"~string\n )~string^add_string,\n \"Ȁ\"~string\n)~string^add_string","type":"string"},{"original":{"name":"ascii_unicode","expr":"'r' + 'ô' + 'le'","value":{"stringValue":"rôle"}},"ast":"_+_(\n _+_(\n \"r\"^#*expr.Constant_StringValue#,\n \"ô\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"le\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"r\"~string,\n \"ô\"~string\n )~string^add_string,\n \"le\"~string\n)~string^add_string","type":"string"},{"original":{"name":"ascii_unicode_unicode_smp","expr":"'a' + 'ÿ' + '🐱'","value":{"stringValue":"aÿ🐱"}},"ast":"_+_(\n _+_(\n \"a\"^#*expr.Constant_StringValue#,\n \"ÿ\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"🐱\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"a\"~string,\n \"ÿ\"~string\n )~string^add_string,\n \"🐱\"~string\n)~string^add_string","type":"string"},{"original":{"name":"empty_unicode","expr":"'' + 'Ω' + ''","value":{"stringValue":"Ω"}},"ast":"_+_(\n _+_(\n \"\"^#*expr.Constant_StringValue#,\n \"Ω\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"\"~string,\n \"Ω\"~string\n )~string^add_string,\n \"\"~string\n)~string^add_string","type":"string"}]},{"name":"contains","tests":[{"original":{"name":"contains_true","expr":"'hello'.contains('he')","value":{"boolValue":true}},"ast":"\"hello\"^#*expr.Constant_StringValue#.contains(\n \"he\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hello\"~string.contains(\n \"he\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_empty","expr":"'hello'.contains('')","value":{"boolValue":true}},"ast":"\"hello\"^#*expr.Constant_StringValue#.contains(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hello\"~string.contains(\n \"\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_false","expr":"'hello'.contains('ol')","value":{"boolValue":false}},"ast":"\"hello\"^#*expr.Constant_StringValue#.contains(\n \"ol\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hello\"~string.contains(\n \"ol\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_multiple","expr":"'abababc'.contains('ababc')","value":{"boolValue":true}},"ast":"\"abababc\"^#*expr.Constant_StringValue#.contains(\n \"ababc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"abababc\"~string.contains(\n \"ababc\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_unicode","expr":"'Straße'.contains('aß')","value":{"boolValue":true}},"ast":"\"Straße\"^#*expr.Constant_StringValue#.contains(\n \"aß\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"Straße\"~string.contains(\n \"aß\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_unicode_smp","expr":"'🐱😀😁'.contains('😀')","value":{"boolValue":true}},"ast":"\"🐱😀😁\"^#*expr.Constant_StringValue#.contains(\n \"😀\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😁\"~string.contains(\n \"😀\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"empty_contains","expr":"''.contains('something')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.contains(\n \"something\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.contains(\n \"something\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.contains('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.contains(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.contains(\n \"\"~string\n)~bool^contains_string","type":"bool"}]},{"name":"bytes_concat","tests":[{"original":{"name":"concat","expr":"b'abc' + b'def'","value":{"bytesValue":"YWJjZGVm"}},"ast":"_+_(\n b\"abc\"^#*expr.Constant_BytesValue#,\n b\"def\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"abc\"~bytes,\n b\"def\"~bytes\n)~bytes^add_bytes","type":"bytes"},{"original":{"name":"left_unit","expr":"b'' + b'\\xffoo'","value":{"bytesValue":"/29v"}},"ast":"_+_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\\xffoo\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"\"~bytes,\n b\"\\xffoo\"~bytes\n)~bytes^add_bytes","type":"bytes"},{"original":{"name":"right_unit","expr":"b'zxy' + b''","value":{"bytesValue":"enh5"}},"ast":"_+_(\n b\"zxy\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"zxy\"~bytes,\n b\"\"~bytes\n)~bytes^add_bytes","type":"bytes"},{"original":{"name":"empty_empty","expr":"b'' + b''","value":{"bytesValue":""}},"ast":"_+_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"\"~bytes,\n b\"\"~bytes\n)~bytes^add_bytes","type":"bytes"}]}]},{"name":"string_ext","suites":[{"name":"char_at","tests":[{"original":{"name":"middle_index","expr":"'tacocat'.charAt(3)","value":{"stringValue":"o"}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.charAt(\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.charAt(\n 3~int\n)~string^string_char_at_int","type":"string"},{"original":{"name":"end_index","expr":"'tacocat'.charAt(7)","value":{"stringValue":""}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.charAt(\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.charAt(\n 7~int\n)~string^string_char_at_int","type":"string"},{"original":{"name":"multiple","expr":"'©αT'.charAt(0) == '©' \u0026\u0026 '©αT'.charAt(1) == 'α' \u0026\u0026 '©αT'.charAt(2) == 'T'"},"ast":"_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n \"©αT\"^#*expr.Constant_StringValue#.charAt(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"©\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n \"©αT\"^#*expr.Constant_StringValue#.charAt(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"α\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _==_(\n \"©αT\"^#*expr.Constant_StringValue#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"T\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n \"©αT\"~string.charAt(\n 0~int\n )~string^string_char_at_int,\n \"©\"~string\n )~bool^equals,\n _==_(\n \"©αT\"~string.charAt(\n 1~int\n )~string^string_char_at_int,\n \"α\"~string\n )~bool^equals\n )~bool^logical_and,\n _==_(\n \"©αT\"~string.charAt(\n 2~int\n )~string^string_char_at_int,\n \"T\"~string\n )~bool^equals\n)~bool^logical_and","type":"bool"}]},{"name":"index_of","tests":[{"original":{"name":"empty_index","expr":"'tacocat'.indexOf('')","value":{"int64Value":"0"}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.indexOf(\n \"\"~string\n)~int^string_index_of_string","type":"int"},{"original":{"name":"string_index","expr":"'tacocat'.indexOf('ac')","value":{"int64Value":"1"}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"ac\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.indexOf(\n \"ac\"~string\n)~int^string_index_of_string","type":"int"},{"original":{"name":"nomatch","expr":"'tacocat'.indexOf('none') == -1"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"none\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"none\"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"empty_index","expr":"'tacocat'.indexOf('', 3) == 3"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 3~int\n)~bool^equals","type":"bool"},{"original":{"name":"char_index","expr":"'tacocat'.indexOf('a', 3) == 5"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"a\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_index","expr":"'tacocat'.indexOf('at', 3) == 5"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"at\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"at\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char","expr":"'ta©o©αT'.indexOf('©') == 2"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©\"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char_index","expr":"'ta©o©αT'.indexOf('©', 3) == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_string_index","expr":"'ta©o©αT'.indexOf('©αT', 3) == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©αT\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©αT\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_string_nomatch_index","expr":"'ta©o©αT'.indexOf('©α', 5) == -1"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©α\"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©α\"~string,\n 5~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"char_index","expr":"'ijk'.indexOf('k') == 2"},"ast":"_==_(\n \"ijk\"^#*expr.Constant_StringValue#.indexOf(\n \"k\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ijk\"~string.indexOf(\n \"k\"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_fullmatch","expr":"'hello wello'.indexOf('hello wello') == 0"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.indexOf(\n \"hello wello\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.indexOf(\n \"hello wello\"~string\n )~int^string_index_of_string,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_index","expr":"'hello wello'.indexOf('ello', 6) == 7"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.indexOf(\n \"ello\"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.indexOf(\n \"ello\"~string,\n 6~int\n )~int^string_index_of_string_int,\n 7~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_nomatch_index","expr":"'hello wello'.indexOf('elbo room!!') == -1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.indexOf(\n \"elbo room!!\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.indexOf(\n \"elbo room!!\"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals","type":"bool"}]},{"name":"last_index_of","tests":[{"original":{"name":"empty_string","expr":"''.lastIndexOf('@@') == -1"},"ast":"_==_(\n \"\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"@@\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\"~string.lastIndexOf(\n \"@@\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"empty_argument","expr":"'tacocat'.lastIndexOf('') == 7"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"\"~string\n )~int^string_last_index_of_string,\n 7~int\n)~bool^equals","type":"bool"},{"original":{"name":"string","expr":"'tacocat'.lastIndexOf('at') == 5"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"at\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"at\"~string\n )~int^string_last_index_of_string,\n 5~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_nomatch","expr":"'tacocat'.lastIndexOf('none') == -1"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"none\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"none\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"empty_index","expr":"'tacocat'.lastIndexOf('', 3) == 3"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"\"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 3~int\n)~bool^equals","type":"bool"},{"original":{"name":"char_index","expr":"'tacocat'.lastIndexOf('a', 3) == 1"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"a\"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char","expr":"'ta©o©αT'.lastIndexOf('©') == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"©\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.lastIndexOf(\n \"©\"~string\n )~int^string_last_index_of_string,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char_index","expr":"'ta©o©αT'.lastIndexOf('©', 3) == 2"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"©\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.lastIndexOf(\n \"©\"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_string_index","expr":"'ta©o©αT'.lastIndexOf('©α', 4) == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"©α\"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.lastIndexOf(\n \"©α\"~string,\n 4~int\n )~int^string_last_index_of_string_int,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_string_index","expr":"'hello wello'.lastIndexOf('ello', 6) == 1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"ello\"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"ello\"~string,\n 6~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_string_nomatch","expr":"'hello wello'.lastIndexOf('low') == -1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"low\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"low\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_string_with_space_nomatch","expr":"'hello wello'.lastIndexOf('elbo room!!') == -1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"elbo room!!\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"elbo room!!\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_fullmatch","expr":"'hello wello'.lastIndexOf('hello wello') == 0"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"hello wello\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"hello wello\"~string\n )~int^string_last_index_of_string,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"repeated_string","expr":"'bananananana'.lastIndexOf('nana', 7) == 6"},"ast":"_==_(\n \"bananananana\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"nana\"^#*expr.Constant_StringValue#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"bananananana\"~string.lastIndexOf(\n \"nana\"~string,\n 7~int\n )~int^string_last_index_of_string_int,\n 6~int\n)~bool^equals","type":"bool"}]},{"name":"ascii_casing","tests":[{"original":{"name":"lowerascii","expr":"'TacoCat'.lowerAscii() == 'tacocat'"},"ast":"_==_(\n \"TacoCat\"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n \"tacocat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCat\"~string.lowerAscii()~string^string_lower_ascii,\n \"tacocat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"lowerascii_unicode","expr":"'TacoCÆt'.lowerAscii() == 'tacocÆt'"},"ast":"_==_(\n \"TacoCÆt\"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n \"tacocÆt\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCÆt\"~string.lowerAscii()~string^string_lower_ascii,\n \"tacocÆt\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"lowerascii_unicode_with_space","expr":"'TacoCÆt Xii'.lowerAscii() == 'tacocÆt xii'"},"ast":"_==_(\n \"TacoCÆt Xii\"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n \"tacocÆt xii\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCÆt Xii\"~string.lowerAscii()~string^string_lower_ascii,\n \"tacocÆt xii\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"upperascii","expr":"'tacoCat'.upperAscii() == 'TACOCAT'"},"ast":"_==_(\n \"tacoCat\"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n \"TACOCAT\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacoCat\"~string.upperAscii()~string^string_upper_ascii,\n \"TACOCAT\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"upperascii_unicode","expr":"'tacoCαt'.upperAscii() == 'TACOCαT'"},"ast":"_==_(\n \"tacoCαt\"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n \"TACOCαT\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacoCαt\"~string.upperAscii()~string^string_upper_ascii,\n \"TACOCαT\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"upperascii_unicode_with_space","expr":"'TacoCÆt Xii'.upperAscii() == 'TACOCÆT XII'"},"ast":"_==_(\n \"TacoCÆt Xii\"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n \"TACOCÆT XII\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCÆt Xii\"~string.upperAscii()~string^string_upper_ascii,\n \"TACOCÆT XII\"~string\n)~bool^equals","type":"bool"}]},{"name":"replace","tests":[{"original":{"name":"no_placeholder","expr":"'12 days 12 hours'.replace('{0}', '2') == '12 days 12 hours'"},"ast":"_==_(\n \"12 days 12 hours\"^#*expr.Constant_StringValue#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"12 days 12 hours\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"12 days 12 hours\"~string.replace(\n \"{0}\"~string,\n \"2\"~string\n )~string^string_replace_string_string,\n \"12 days 12 hours\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"basic","expr":"'{0} days {0} hours'.replace('{0}', '2') == '2 days 2 hours'"},"ast":"_==_(\n \"{0} days {0} hours\"^#*expr.Constant_StringValue#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"2 days 2 hours\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"{0} days {0} hours\"~string.replace(\n \"{0}\"~string,\n \"2\"~string\n )~string^string_replace_string_string,\n \"2 days 2 hours\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"chained","expr":"'{0} days {0} hours'.replace('{0}', '2', 1).replace('{0}', '23') == '2 days 23 hours'"},"ast":"_==_(\n \"{0} days {0} hours\"^#*expr.Constant_StringValue#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"23\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"2 days 23 hours\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"{0} days {0} hours\"~string.replace(\n \"{0}\"~string,\n \"2\"~string,\n 1~int\n )~string^string_replace_string_string_int.replace(\n \"{0}\"~string,\n \"23\"~string\n )~string^string_replace_string_string,\n \"2 days 23 hours\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode","expr":"'1 ©αT taco'.replace('αT', 'o©α') == '1 ©o©α taco'"},"ast":"_==_(\n \"1 ©αT taco\"^#*expr.Constant_StringValue#.replace(\n \"αT\"^#*expr.Constant_StringValue#,\n \"o©α\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"1 ©o©α taco\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"1 ©αT taco\"~string.replace(\n \"αT\"~string,\n \"o©α\"~string\n )~string^string_replace_string_string,\n \"1 ©o©α taco\"~string\n)~bool^equals","type":"bool"}]},{"name":"split","tests":[{"original":{"name":"empty","expr":"'hello world'.split(' ') == ['hello', 'world']"},"ast":"_==_(\n \"hello world\"^#*expr.Constant_StringValue#.split(\n \" \"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"hello\"^#*expr.Constant_StringValue#,\n \"world\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello world\"~string.split(\n \" \"~string\n )~list(string)^string_split_string,\n [\n \"hello\"~string,\n \"world\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"zero_limit","expr":"'hello world events!'.split(' ', 0) == []"},"ast":"_==_(\n \"hello world events!\"^#*expr.Constant_StringValue#.split(\n \" \"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello world events!\"~string.split(\n \" \"~string,\n 0~int\n )~list(string)^string_split_string_int,\n []~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"one_limit","expr":"'hello world events!'.split(' ', 1) == ['hello world events!']"},"ast":"_==_(\n \"hello world events!\"^#*expr.Constant_StringValue#.split(\n \" \"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"hello world events!\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello world events!\"~string.split(\n \" \"~string,\n 1~int\n )~list(string)^string_split_string_int,\n [\n \"hello world events!\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_negative_limit","expr":"'o©o©o©o'.split('©', -1) == ['o', 'o', 'o', 'o']"},"ast":"_==_(\n \"o©o©o©o\"^#*expr.Constant_StringValue#.split(\n \"©\"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"o\"^#*expr.Constant_StringValue#,\n \"o\"^#*expr.Constant_StringValue#,\n \"o\"^#*expr.Constant_StringValue#,\n \"o\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"o©o©o©o\"~string.split(\n \"©\"~string,\n -1~int\n )~list(string)^string_split_string_int,\n [\n \"o\"~string,\n \"o\"~string,\n \"o\"~string,\n \"o\"~string\n ]~list(string)\n)~bool^equals","type":"bool"}]},{"name":"substring","tests":[{"original":{"name":"start","expr":"'tacocat'.substring(4) == 'cat'"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 4~int\n )~string^string_substring_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"start_with_max_length","expr":"'tacocat'.substring(7) == ''"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 7~int\n )~string^string_substring_int,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"start_and_end","expr":"'tacocat'.substring(0, 4) == 'taco'"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"taco\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 0~int,\n 4~int\n )~string^string_substring_int_int,\n \"taco\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"start_and_end_equal_value","expr":"'tacocat'.substring(4, 4) == ''"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 4~int,\n 4~int\n )~string^string_substring_int_int,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_start_and_end","expr":"'ta©o©αT'.substring(2, 6) == '©o©α'"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.substring(\n 2^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"©o©α\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.substring(\n 2~int,\n 6~int\n )~string^string_substring_int_int,\n \"©o©α\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_start_and_end_equal_value","expr":"'ta©o©αT'.substring(7, 7) == ''"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.substring(\n 7~int,\n 7~int\n )~string^string_substring_int_int,\n \"\"~string\n)~bool^equals","type":"bool"}]},{"name":"trim","tests":[{"original":{"name":"blank_spaces_escaped_chars","expr":"' \\f\\n\\r\\t\\vtext '.trim() == 'text'"},"ast":"_==_(\n \" \\f\\n\\r\\t\\vtext \"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \" \\f\\n\\r\\t\\vtext \"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_space_chars_1","expr":"'\\u0085\\u00a0\\u1680text'.trim() == 'text'"},"ast":"_==_(\n \"\\u0085\\u00a0\\u1680text\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\\u0085\\u00a0\\u1680text\"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_space_chars_2","expr":"'text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009'.trim() == 'text'"},"ast":"_==_(\n \"text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009\"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_space_chars_3","expr":"'\\u200atext\\u2028\\u2029\\u202F\\u205F\\u3000'.trim() == 'text'"},"ast":"_==_(\n \"\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000\"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_no_trim","expr":"'\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'.trim() == '\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'"},"ast":"_==_(\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"~string.trim()~string^string_trim,\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"~string\n)~bool^equals","type":"bool"}]},{"name":"join","tests":[{"original":{"name":"empty_separator","expr":"['x', 'y'].join() == 'xy'"},"ast":"_==_(\n [\n \"x\"^#*expr.Constant_StringValue#,\n \"y\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n \"xy\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"x\"~string,\n \"y\"~string\n ]~list(string).join()~string^list_join,\n \"xy\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"dash_separator","expr":"['x', 'y'].join('-') == 'x-y'"},"ast":"_==_(\n [\n \"x\"^#*expr.Constant_StringValue#,\n \"y\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join(\n \"-\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"x-y\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"x\"~string,\n \"y\"~string\n ]~list(string).join(\n \"-\"~string\n )~string^list_join_string,\n \"x-y\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"empty_string_empty_separator","expr":"[].join() == ''"},"ast":"_==_(\n []^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n []~list(string).join()~string^list_join,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"empty_string_dash_separator","expr":"[].join('-') == ''"},"ast":"_==_(\n []^#*expr.Expr_ListExpr#.join(\n \"-\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n []~list(string).join(\n \"-\"~string\n )~string^list_join_string,\n \"\"~string\n)~bool^equals","type":"bool"}]},{"name":"quote","tests":[{"original":{"name":"multiline","expr":"strings.quote(\"first\\nsecond\") == \"\\\"first\\\\nsecond\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"first\\nsecond\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"first\\\\nsecond\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"first\\nsecond\"~string\n )~string^strings_quote,\n \"\\\"first\\\\nsecond\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"escaped","expr":"strings.quote(\"bell\\a\") == \"\\\"bell\\\\a\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"bell\\a\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"bell\\\\a\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"bell\\a\"~string\n )~string^strings_quote,\n \"\\\"bell\\\\a\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"backspace","expr":"strings.quote(\"\\bbackspace\") == \"\\\"\\\\bbackspace\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"\\bbackspace\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"\\\\bbackspace\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"\\bbackspace\"~string\n )~string^strings_quote,\n \"\\\"\\\\bbackspace\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"form_feed","expr":"strings.quote(\"\\fform feed\") == \"\\\"\\\\fform feed\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"\\fform feed\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"\\\\fform feed\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"\\fform feed\"~string\n )~string^strings_quote,\n \"\\\"\\\\fform feed\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"carriage_return","expr":"strings.quote(\"carriage \\r return\") == \"\\\"carriage \\\\r return\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"carriage \\r return\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"carriage \\\\r return\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"carriage \\r return\"~string\n )~string^strings_quote,\n \"\\\"carriage \\\\r return\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"horizontal_tab","expr":"strings.quote(\"horizontal tab\\t\") == \"\\\"horizontal tab\\\\t\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"horizontal tab\\t\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"horizontal tab\\\\t\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"horizontal tab\\t\"~string\n )~string^strings_quote,\n \"\\\"horizontal tab\\\\t\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"vertical_tab","expr":"strings.quote(\"vertical \\v tab\") == \"\\\"vertical \\\\v tab\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"vertical \\v tab\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"vertical \\\\v tab\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"vertical \\v tab\"~string\n )~string^strings_quote,\n \"\\\"vertical \\\\v tab\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"double_slash","expr":"strings.quote(\"double \\\\\\\\ slash\") == \"\\\"double \\\\\\\\\\\\\\\\ slash\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"double \\\\\\\\ slash\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"double \\\\\\\\\\\\\\\\ slash\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"double \\\\\\\\ slash\"~string\n )~string^strings_quote,\n \"\\\"double \\\\\\\\\\\\\\\\ slash\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"two_escape_sequences","expr":"strings.quote(\"two escape sequences \\\\a\\\\n\") == \"\\\"two escape sequences \\\\\\\\a\\\\\\\\n\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"two escape sequences \\\\a\\\\n\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"two escape sequences \\\\\\\\a\\\\\\\\n\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"two escape sequences \\\\a\\\\n\"~string\n )~string^strings_quote,\n \"\\\"two escape sequences \\\\\\\\a\\\\\\\\n\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"verbatim","expr":"strings.quote(\"verbatim\") == \"\\\"verbatim\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"verbatim\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"verbatim\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"verbatim\"~string\n )~string^strings_quote,\n \"\\\"verbatim\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"ends_with","expr":"strings.quote(\"ends with \\\\\") == \"\\\"ends with \\\\\\\\\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"ends with \\\\\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"ends with \\\\\\\\\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"ends with \\\\\"~string\n )~string^strings_quote,\n \"\\\"ends with \\\\\\\\\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"starts_with","expr":"strings.quote(\"\\\\ starts with\") == \"\\\"\\\\\\\\ starts with\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"\\\\ starts with\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"\\\\\\\\ starts with\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"\\\\ starts with\"~string\n )~string^strings_quote,\n \"\\\"\\\\\\\\ starts with\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"printable_unicode","expr":"strings.quote(\"printable unicode😀\") == \"\\\"printable unicode😀\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"printable unicode😀\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"printable unicode😀\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"printable unicode😀\"~string\n )~string^strings_quote,\n \"\\\"printable unicode😀\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"mid_string_quote","expr":"strings.quote(\"mid string \\\" quote\") == \"\\\"mid string \\\\\\\" quote\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"mid string \\\" quote\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"mid string \\\\\\\" quote\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"mid string \\\" quote\"~string\n )~string^strings_quote,\n \"\\\"mid string \\\\\\\" quote\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"single_quote_with_double_quote","expr":"strings.quote('single-quote with \"double quote\"') == \"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"single-quote with \\\"double quote\\\"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"single-quote with \\\"double quote\\\"\"~string\n )~string^strings_quote,\n \"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"size_unicode_char","expr":"strings.quote(\"size('ÿ')\") == \"\\\"size('ÿ')\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"size('ÿ')\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"size('ÿ')\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"size('ÿ')\"~string\n )~string^strings_quote,\n \"\\\"size('ÿ')\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"size_unicode_string","expr":"strings.quote(\"size('πέντε')\") == \"\\\"size('πέντε')\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"size('πέντε')\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"size('πέντε')\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"size('πέντε')\"~string\n )~string^strings_quote,\n \"\\\"size('πέντε')\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode","expr":"strings.quote(\"завтра\") == \"\\\"завтра\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"завтра\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"завтра\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"завтра\"~string\n )~string^strings_quote,\n \"\\\"завтра\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_code_points","expr":"strings.quote(\"\\U0001F431\\U0001F600\\U0001F61B\")","value":{"stringValue":"\"🐱😀😛\""}},"ast":"strings^#*expr.Expr_IdentExpr#.quote(\n \"🐱😀😛\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"strings.quote(\n \"🐱😀😛\"~string\n)~string^strings_quote","type":"string"},{"original":{"name":"unicode_2","expr":"strings.quote(\"ta©o©αT\") == \"\\\"ta©o©αT\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"ta©o©αT\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"ta©o©αT\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"ta©o©αT\"~string\n )~string^strings_quote,\n \"\\\"ta©o©αT\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"empty_quote","expr":"strings.quote(\"\")","value":{"stringValue":"\"\""}},"ast":"strings^#*expr.Expr_IdentExpr#.quote(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"strings.quote(\n \"\"~string\n)~string^strings_quote","type":"string"}]},{"name":"format","tests":[{"original":{"name":"no-op","expr":"\"no substitution\".format([])","value":{"stringValue":"no substitution"}},"ast":"\"no substitution\"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"no substitution\"~string.format(\n []~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"mid-string substitution","expr":"\"str is %s and some more\".format([\"filler\"])","value":{"stringValue":"str is filler and some more"}},"ast":"\"str is %s and some more\"^#*expr.Constant_StringValue#.format(\n [\n \"filler\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"str is %s and some more\"~string.format(\n [\n \"filler\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"percent escaping","expr":"\"%% and also %%\".format([])","value":{"stringValue":"% and also %"}},"ast":"\"%% and also %%\"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%% and also %%\"~string.format(\n []~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"substitution inside escaped percent signs","expr":"\"%%%s%%\".format([\"text\"])","value":{"stringValue":"%text%"}},"ast":"\"%%%s%%\"^#*expr.Constant_StringValue#.format(\n [\n \"text\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%%%s%%\"~string.format(\n [\n \"text\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"substitution with one escaped percent sign on the right","expr":"\"%s%%\".format([\"percent on the right\"])","value":{"stringValue":"percent on the right%"}},"ast":"\"%s%%\"^#*expr.Constant_StringValue#.format(\n [\n \"percent on the right\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s%%\"~string.format(\n [\n \"percent on the right\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"substitution with one escaped percent sign on the left","expr":"\"%%%s\".format([\"percent on the left\"])","value":{"stringValue":"%percent on the left"}},"ast":"\"%%%s\"^#*expr.Constant_StringValue#.format(\n [\n \"percent on the left\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%%%s\"~string.format(\n [\n \"percent on the left\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"multiple substitutions","expr":"\"%d %d %d, %s %s %s, %d %d %d, %s %s %s\".format([1, 2, 3, \"A\", \"B\", \"C\", 4, 5, 6, \"D\", \"E\", \"F\"])","value":{"stringValue":"1 2 3, A B C, 4 5 6, D E F"}},"ast":"\"%d %d %d, %s %s %s, %d %d %d, %s %s %s\"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n \"A\"^#*expr.Constant_StringValue#,\n \"B\"^#*expr.Constant_StringValue#,\n \"C\"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n \"D\"^#*expr.Constant_StringValue#,\n \"E\"^#*expr.Constant_StringValue#,\n \"F\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d %d %d, %s %s %s, %d %d %d, %s %s %s\"~string.format(\n [\n 1~int,\n 2~int,\n 3~int,\n \"A\"~string,\n \"B\"~string,\n \"C\"~string,\n 4~int,\n 5~int,\n 6~int,\n \"D\"~string,\n \"E\"~string,\n \"F\"~string\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"percent sign escape sequence support","expr":"\"%%escaped %s%%\".format([\"percent\"])","value":{"stringValue":"%escaped percent%"}},"ast":"\"%%escaped %s%%\"^#*expr.Constant_StringValue#.format(\n [\n \"percent\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%%escaped %s%%\"~string.format(\n [\n \"percent\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"fixed point formatting clause","expr":"\"%.3f\".format([1.2345])","value":{"stringValue":"1.234"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"binary formatting clause","expr":"\"this is 5 in binary: %b\".format([5])","value":{"stringValue":"this is 5 in binary: 101"}},"ast":"\"this is 5 in binary: %b\"^#*expr.Constant_StringValue#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"this is 5 in binary: %b\"~string.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"uint support for binary formatting","expr":"\"unsigned 64 in binary: %b\".format([uint(64)])","value":{"stringValue":"unsigned 64 in binary: 1000000"}},"ast":"\"unsigned 64 in binary: %b\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"unsigned 64 in binary: %b\"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"bool support for binary formatting","expr":"\"bit set from bool: %b\".format([true])","value":{"stringValue":"bit set from bool: 1"}},"ast":"\"bit set from bool: %b\"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"bit set from bool: %b\"~string.format(\n [\n true~bool\n ]~list(bool)\n)~string^string_format","type":"string"},{"original":{"name":"octal formatting clause","expr":"\"%o\".format([11])","value":{"stringValue":"13"}},"ast":"\"%o\"^#*expr.Constant_StringValue#.format(\n [\n 11^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%o\"~string.format(\n [\n 11~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"uint support for octal formatting clause","expr":"\"this is an unsigned octal: %o\".format([uint(65535)])","value":{"stringValue":"this is an unsigned octal: 177777"}},"ast":"\"this is an unsigned octal: %o\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 65535^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"this is an unsigned octal: %o\"~string.format(\n [\n uint(\n 65535~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"lowercase hexadecimal formatting clause","expr":"\"%x is 20 in hexadecimal\".format([30])","value":{"stringValue":"1e is 20 in hexadecimal"}},"ast":"\"%x is 20 in hexadecimal\"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x is 20 in hexadecimal\"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"uppercase hexadecimal formatting clause","expr":"\"%X is 20 in hexadecimal\".format([30])","value":{"stringValue":"1E is 20 in hexadecimal"}},"ast":"\"%X is 20 in hexadecimal\"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X is 20 in hexadecimal\"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"unsigned support for hexadecimal formatting clause","expr":"\"%X is 6000 in hexadecimal\".format([uint(6000)])","value":{"stringValue":"1770 is 6000 in hexadecimal"}},"ast":"\"%X is 6000 in hexadecimal\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 6000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X is 6000 in hexadecimal\"~string.format(\n [\n uint(\n 6000~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"string support with hexadecimal formatting clause","expr":"\"%x\".format([\"Hello world!\"])","value":{"stringValue":"48656c6c6f20776f726c6421"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n \"Hello world!\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n \"Hello world!\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"string support with uppercase hexadecimal formatting clause","expr":"\"%X\".format([\"Hello world!\"])","value":{"stringValue":"48656C6C6F20776F726C6421"}},"ast":"\"%X\"^#*expr.Constant_StringValue#.format(\n [\n \"Hello world!\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X\"~string.format(\n [\n \"Hello world!\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"byte support with hexadecimal formatting clause","expr":"\"%x\".format([b\"byte string\"])","value":{"stringValue":"6279746520737472696e67"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n b\"byte string\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n b\"byte string\"~bytes\n ]~list(bytes)\n)~string^string_format","type":"string"},{"original":{"name":"byte support with uppercase hexadecimal formatting clause","expr":"\"%X\".format([b\"byte string\"])","value":{"stringValue":"6279746520737472696E67"}},"ast":"\"%X\"^#*expr.Constant_StringValue#.format(\n [\n b\"byte string\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X\"~string.format(\n [\n b\"byte string\"~bytes\n ]~list(bytes)\n)~string^string_format","type":"string"},{"original":{"name":"scientific notation formatting clause","expr":"\"%.6e\".format([1052.032911275])","value":{"stringValue":"1.052033e+03"}},"ast":"\"%.6e\"^#*expr.Constant_StringValue#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.6e\"~string.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"default precision for fixed-point clause","expr":"\"%f\".format([2.71828])","value":{"stringValue":"2.718280"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"default precision for scientific notation","expr":"\"%e\".format([2.71828])","value":{"stringValue":"2.718280e+00"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"NaN support for scientific notation","expr":"\"%e\".format([double(\"NaN\")])","value":{"stringValue":"NaN"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n double(\n \"NaN\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"positive infinity support for scientific notation","expr":"\"%e\".format([double(\"Infinity\")])","value":{"stringValue":"Infinity"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n double(\n \"Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"negative infinity support for scientific notation","expr":"\"%e\".format([double(\"-Infinity\")])","value":{"stringValue":"-Infinity"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"NaN support for decimal","expr":"\"%d\".format([double(\"NaN\")])","value":{"stringValue":"NaN"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n double(\n \"NaN\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"positive infinity support for decimal","expr":"\"%d\".format([double(\"Infinity\")])","value":{"stringValue":"Infinity"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n double(\n \"Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"negative infinity support for decimal","expr":"\"%d\".format([double(\"-Infinity\")])","value":{"stringValue":"-Infinity"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"NaN support for fixed-point","expr":"\"%f\".format([double(\"NaN\")])","value":{"stringValue":"NaN"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n double(\n \"NaN\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"positive infinity support for fixed-point","expr":"\"%f\".format([double(\"Infinity\")])","value":{"stringValue":"Infinity"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n double(\n \"Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"negative infinity support for fixed-point","expr":"\"%f\".format([double(\"-Infinity\")])","value":{"stringValue":"-Infinity"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"uint support for decimal clause","expr":"\"%d\".format([uint(64)])","value":{"stringValue":"64"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"null support for string","expr":"\"%s\".format([null])","value":{"stringValue":"null"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n null~null\n ]~list(null)\n)~string^string_format","type":"string"},{"original":{"name":"int support for string","expr":"\"%s\".format([999999999999])","value":{"stringValue":"999999999999"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n 999999999999^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n 999999999999~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"bytes support for string","expr":"\"%s\".format([b\"xyz\"])","value":{"stringValue":"xyz"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n b\"xyz\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n b\"xyz\"~bytes\n ]~list(bytes)\n)~string^string_format","type":"string"},{"original":{"name":"type() support for string","expr":"\"%s\".format([type(\"test string\")])","value":{"stringValue":"string"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n type(\n \"test string\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n type(\n \"test string\"~string\n )~type(string)^type\n ]~list(type(string))\n)~string^string_format","type":"string"},{"original":{"name":"timestamp support for string","expr":"\"%s\".format([timestamp(\"2023-02-03T23:31:20+00:00\")])","value":{"stringValue":"2023-02-03T23:31:20Z"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n timestamp(\n \"2023-02-03T23:31:20+00:00\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n timestamp(\n \"2023-02-03T23:31:20+00:00\"~string\n )~timestamp^string_to_timestamp\n ]~list(timestamp)\n)~string^string_format","type":"string"},{"original":{"name":"duration support for string","expr":"\"%s\".format([duration(\"1h45m47s\")])","value":{"stringValue":"6347s"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n duration(\n \"1h45m47s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n duration(\n \"1h45m47s\"~string\n )~duration^string_to_duration\n ]~list(duration)\n)~string^string_format","type":"string"},{"original":{"name":"list support for string","expr":"\"%s\".format([[\"abc\", 3.14, null, [9, 8, 7, 6], timestamp(\"2023-02-03T23:31:20Z\")]])","value":{"stringValue":"[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n [\n \"abc\"^#*expr.Constant_StringValue#,\n 3.14^#*expr.Constant_DoubleValue#,\n null^#*expr.Constant_NullValue#,\n [\n 9^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n timestamp(\n \"2023-02-03T23:31:20Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n [\n \"abc\"~string,\n 3.14~double,\n null~null,\n [\n 9~int,\n 8~int,\n 7~int,\n 6~int\n ]~list(int),\n timestamp(\n \"2023-02-03T23:31:20Z\"~string\n )~timestamp^string_to_timestamp\n ]~list(dyn)\n ]~list(list(dyn))\n)~string^string_format","type":"string"},{"original":{"name":"map support for string","expr":"\"%s\".format([{\"key1\": b\"xyz\", \"key5\": null, \"key2\": duration(\"2h\"), \"key4\": true, \"key3\": 2.71828}])","value":{"stringValue":"{key1: xyz, key2: 7200s, key3: 2.71828, key4: true, key5: null}"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n \"key1\"^#*expr.Constant_StringValue#:b\"xyz\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key5\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:duration(\n \"2h\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"key4\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key3\"^#*expr.Constant_StringValue#:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n {\n \"key1\"~string:b\"xyz\"~bytes,\n \"key5\"~string:null~null,\n \"key2\"~string:duration(\n \"2h\"~string\n )~duration^string_to_duration,\n \"key4\"~string:true~bool,\n \"key3\"~string:2.71828~double\n }~map(string, dyn)\n ]~list(map(string, dyn))\n)~string^string_format","type":"string"},{"original":{"name":"map support (all key types)","expr":"\"%s\".format([{1: \"value1\", uint(2): \"value2\", true: double(\"NaN\")}])","value":{"stringValue":"{1: value1, 2: value2, true: NaN}"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:\"value1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n uint(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#:\"value2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n {\n 1~int:\"value1\"~string,\n uint(\n 2~int\n )~uint^int64_to_uint64:\"value2\"~string,\n true~bool:double(\n \"NaN\"~string\n )~double^string_to_double\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format","type":"string"},{"original":{"name":"boolean support for %s","expr":"\"%s, %s\".format([true, false])","value":{"stringValue":"true, false"}},"ast":"\"%s, %s\"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s, %s\"~string.format(\n [\n true~bool,\n false~bool\n ]~list(bool)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for string formatting clause","expr":"\"%s\".format([dyn(\"a string\")])","value":{"stringValue":"a string"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n \"a string\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n \"a string\"~string\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for numbers with string formatting clause","expr":"\"%s, %s\".format([dyn(32), dyn(56.8)])","value":{"stringValue":"32, 56.8"}},"ast":"\"%s, %s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 32^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 56.8^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s, %s\"~string.format(\n [\n dyn(\n 32~int\n )~dyn^to_dyn,\n dyn(\n 56.8~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for integer formatting clause","expr":"\"%d\".format([dyn(128)])","value":{"stringValue":"128"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 128^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n dyn(\n 128~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for integer formatting clause (unsigned)","expr":"\"%d\".format([dyn(256u)])","value":{"stringValue":"256"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 256u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n dyn(\n 256u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for hex formatting clause","expr":"\"%x\".format([dyn(22)])","value":{"stringValue":"16"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n dyn(\n 22~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for hex formatting clause (uppercase)","expr":"\"%X\".format([dyn(26)])","value":{"stringValue":"1A"}},"ast":"\"%X\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 26^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X\"~string.format(\n [\n dyn(\n 26~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for unsigned hex formatting clause","expr":"\"%x\".format([dyn(500u)])","value":{"stringValue":"1f4"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 500u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n dyn(\n 500u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for fixed-point formatting clause","expr":"\"%.3f\".format([dyn(4.5)])","value":{"stringValue":"4.500"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 4.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n dyn(\n 4.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for scientific notation","expr":"\"%e\".format([dyn(2.71828)])","value":{"stringValue":"2.718280e+00"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 2.71828^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n dyn(\n 2.71828~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype NaN/infinity support","expr":"\"%s\".format([[double(\"NaN\"), double(\"Infinity\"), double(\"-Infinity\")]])","value":{"stringValue":"[NaN, Infinity, -Infinity]"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n [\n double(\n \"NaN\"~string\n )~double^string_to_double,\n double(\n \"Infinity\"~string\n )~double^string_to_double,\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n ]~list(list(double))\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for timestamp","expr":"\"%s\".format([dyn(timestamp(\"2009-11-10T23:00:00Z\"))])","value":{"stringValue":"2009-11-10T23:00:00Z"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n timestamp(\n \"2009-11-10T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n timestamp(\n \"2009-11-10T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for duration","expr":"\"%s\".format([dyn(duration(\"8747s\"))])","value":{"stringValue":"8747s"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n duration(\n \"8747s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n duration(\n \"8747s\"~string\n )~duration^string_to_duration\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for lists","expr":"\"%s\".format([dyn([6, 4.2, \"a string\"])])","value":{"stringValue":"[6, 4.2, a string]"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n [\n 6^#*expr.Constant_Int64Value#,\n 4.2^#*expr.Constant_DoubleValue#,\n \"a string\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n [\n 6~int,\n 4.2~double,\n \"a string\"~string\n ]~list(dyn)\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for maps","expr":"\"%s\".format([{\"strKey\":\"x\", 6:duration(\"422s\"), true:42}])","value":{"stringValue":"{6: 422s, strKey: x, true: 42}"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n \"strKey\"^#*expr.Constant_StringValue#:\"x\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:duration(\n \"422s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n {\n \"strKey\"~string:\"x\"~string,\n 6~int:duration(\n \"422s\"~string\n )~duration^string_to_duration,\n true~bool:42~int\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format","type":"string"},{"original":{"name":"string substitution in a string variable","expr":"str_var.format([\"filler\"])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%s"}}},"value":{"stringValue":"filler"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n \"filler\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n \"filler\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"multiple substitutions in a string variable","expr":"str_var.format([1, 2, 3, \"A\", \"B\", \"C\", 4, 5, 6, \"D\", \"E\", \"F\"])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%d %d %d, %s %s %s, %d %d %d, %s %s %s"}}},"value":{"stringValue":"1 2 3, A B C, 4 5 6, D E F"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n \"A\"^#*expr.Constant_StringValue#,\n \"B\"^#*expr.Constant_StringValue#,\n \"C\"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n \"D\"^#*expr.Constant_StringValue#,\n \"E\"^#*expr.Constant_StringValue#,\n \"F\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 1~int,\n 2~int,\n 3~int,\n \"A\"~string,\n \"B\"~string,\n \"C\"~string,\n 4~int,\n 5~int,\n 6~int,\n \"D\"~string,\n \"E\"~string,\n \"F\"~string\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"substitution inside escaped percent signs in a string variable","expr":"str_var.format([\"text\"])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%%%s%%"}}},"value":{"stringValue":"%text%"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n \"text\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n \"text\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"fixed point formatting clause in a string variable","expr":"str_var.format([1.2345])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%.3f"}}},"value":{"stringValue":"1.234"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"binary formatting clause in a string variable","expr":"str_var.format([5])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%b"}}},"value":{"stringValue":"101"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"scientific notation formatting clause in a string variable","expr":"str_var.format([1052.032911275])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%.6e"}}},"value":{"stringValue":"1.052033e+03"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"default precision for fixed-point clause in a string variable","expr":"str_var.format([2.71828])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%f"}}},"value":{"stringValue":"2.718280"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_insignificant_zeroes_removed","expr":"\"%.0f\".format([123.000000])","value":{"stringValue":"123"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 123^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 123~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_positive_round_to_whole_number","expr":"\"%.0f\".format([3.5001])","value":{"stringValue":"4"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 3.5001^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 3.5001~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_negative_truncate_to_whole_number","expr":"\"%.0f\".format([3.4999])","value":{"stringValue":"3"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 3.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 3.4999~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_halfway_round_up_to_nearest_even","expr":"\"%.0f\".format([1.5])","value":{"stringValue":"2"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 1.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 1.5~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_halfway_truncate_to_nearest_even","expr":"\"%.0f\".format([2.5])","value":{"stringValue":"2"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 2.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 2.5~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_positive_round_up","expr":"\"%.3f\".format([123.4999])","value":{"stringValue":"123.500"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n 123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n 123.4999~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_positive_round_down","expr":"\"%.3f\".format([123.4994])","value":{"stringValue":"123.499"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n 123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n 123.4994~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_negative_round_up","expr":"\"%.3f\".format([-123.4999])","value":{"stringValue":"-123.500"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n -123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n -123.4999~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_negative_round_down","expr":"\"%.3f\".format([-123.4994])","value":{"stringValue":"-123.499"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n -123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n -123.4994~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_zero_padding","expr":"\"%.5f\".format([-1.2])","value":{"stringValue":"-1.20000"}},"ast":"\"%.5f\"^#*expr.Constant_StringValue#.format(\n [\n -1.2^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.5f\"~string.format(\n [\n -1.2~double\n ]~list(double)\n)~string^string_format","type":"string"}]},{"name":"format_errors","tests":[{"original":{"name":"unrecognized formatting clause","expr":"\"%a\".format([1])","disableCheck":true,"evalError":{"errors":[{"message":"could not parse formatting clause: unrecognized formatting clause \"a\""}]}},"ast":"\"%a\"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:12: could not parse formatting clause: unrecognized formatting clause \"a\"\n | \"%a\".format([1])\n | ...........^"},{"original":{"name":"out of bounds arg index","expr":"\"%d %d %d\".format([0, 1])","disableCheck":true,"evalError":{"errors":[{"message":"index 2 out of range"}]}},"ast":"\"%d %d %d\"^#*expr.Constant_StringValue#.format(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: index 2 out of range\n | \"%d %d %d\".format([0, 1])\n | .................^"},{"original":{"name":"string substitution is not allowed with binary clause","expr":"\"string is %b\".format([\"abc\"])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers and bools can be formatted as binary, was given string"}]}},"ast":"\"string is %b\"^#*expr.Constant_StringValue#.format(\n [\n \"abc\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, and bools can be formatted as binary, was given string\n | \"string is %b\".format([\"abc\"])\n | .......................^"},{"original":{"name":"duration substitution not allowed with decimal clause","expr":"\"%d\".format([duration(\"30m2s\")])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: decimal clause can only be used on integers, was given google.protobuf.Duration"}]}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n duration(\n \"30m2s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:22: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given google.protobuf.Duration\n | \"%d\".format([duration(\"30m2s\")])\n | .....................^"},{"original":{"name":"string substitution not allowed with octal clause","expr":"\"octal: %o\".format([\"a string\"])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: octal clause can only be used on integers, was given string"}]}},"ast":"\"octal: %o\"^#*expr.Constant_StringValue#.format(\n [\n \"a string\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:21: error during formatting: octal clause can only be used on ints and uints, was given string\n | \"octal: %o\".format([\"a string\"])\n | ....................^"},{"original":{"name":"double substitution not allowed with hex clause","expr":"\"double is %x\".format([0.5])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given double"}]}},"ast":"\"double is %x\"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given double\n | \"double is %x\".format([0.5])\n | .......................^"},{"original":{"name":"uppercase not allowed for scientific clause","expr":"\"double is %E\".format([0.5])","disableCheck":true,"evalError":{"errors":[{"message":"could not parse formatting clause: unrecognized formatting clause \"E\""}]}},"ast":"\"double is %E\"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:22: could not parse formatting clause: unrecognized formatting clause \"E\"\n | \"double is %E\".format([0.5])\n | .....................^"},{"original":{"name":"object not allowed","expr":"\"object is %s\".format([cel.expr.conformance.proto3.TestAllTypes{}])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes"}]}},"ast":"\"object is %s\"^#*expr.Constant_StringValue#.format(\n [\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:64: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | \"object is %s\".format([cel.expr.conformance.proto3.TestAllTypes{}])\n | ...............................................................^"},{"original":{"name":"object inside list","expr":"\"%s\".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes"}]}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:61: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | \"%s\".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])\n | ............................................................^"},{"original":{"name":"object inside map","expr":"\"%s\".format([{1: \"a\", 2: cel.expr.conformance.proto3.TestAllTypes{}}])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes"}]}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:66: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | \"%s\".format([{1: \"a\", 2: cel.expr.conformance.proto3.TestAllTypes{}}])\n | .................................................................^"},{"original":{"name":"null not allowed for %d","expr":"\"null: %d\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: decimal clause can only be used on integers, was given null_type"}]}},"ast":"\"null: %d\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given null_type\n | \"null: %d\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %e","expr":"\"null: %e\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: scientific clause can only be used on doubles, was given null_type"}]}},"ast":"\"null: %e\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: scientific clause can only be used on ints, uints, and doubles, was given null_type\n | \"null: %e\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %f","expr":"\"null: %f\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: fixed-point clause can only be used on doubles, was given null_type"}]}},"ast":"\"null: %f\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: fixed-point clause can only be used on ints, uints, and doubles, was given null_type\n | \"null: %f\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %x","expr":"\"null: %x\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type"}]}},"ast":"\"null: %x\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | \"null: %x\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %X","expr":"\"null: %X\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type"}]}},"ast":"\"null: %X\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | \"null: %X\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %b","expr":"\"null: %b\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers and bools can be formatted as binary, was given null_type"}]}},"ast":"\"null: %b\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, and bools can be formatted as binary, was given null_type\n | \"null: %b\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %o","expr":"\"null: %o\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: octal clause can only be used on integers, was given null_type"}]}},"ast":"\"null: %o\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: octal clause can only be used on ints and uints, was given null_type\n | \"null: %o\".format([null])\n | ...................^"}]},{"name":"value_errors","tests":[{"original":{"name":"charat_out_of_range","expr":"'tacocat'.charAt(30) == ''","evalError":{"errors":[{"message":"index out of range: 30"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.charAt(\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.charAt(\n 30~int\n )~string^string_char_at_int,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"indexof_out_of_range","expr":"'tacocat'.indexOf('a', 30) == -1","evalError":{"errors":[{"message":"index out of range: 30"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"a\"~string,\n 30~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"lastindexof_negative_index","expr":"'tacocat'.lastIndexOf('a', -1) == -1","evalError":{"errors":[{"message":"index out of range: -1"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"a\"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"a\"~string,\n -1~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"lastindexof_out_of_range","expr":"'tacocat'.lastIndexOf('a', 30) == -1","evalError":{"errors":[{"message":"index out of range: 30"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"a\"~string,\n 30~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"substring_out_of_range","expr":"'tacocat'.substring(40) == 'cat'","evalError":{"errors":[{"message":"index out of range: 40"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 40^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 40~int\n )~string^string_substring_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_negative_index","expr":"'tacocat'.substring(-1) == 'cat'","evalError":{"errors":[{"message":"index out of range: -1"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n -1~int\n )~string^string_substring_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_end_index_out_of_range","expr":"'tacocat'.substring(1, 50) == 'cat'","evalError":{"errors":[{"message":"index out of range: 50"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 1~int,\n 50~int\n )~string^string_substring_int_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_begin_index_out_of_range","expr":"'tacocat'.substring(49, 50) == 'cat'","evalError":{"errors":[{"message":"index out of range: 49"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 49^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 49~int,\n 50~int\n )~string^string_substring_int_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_end_index_greater_than_begin_index","expr":"'tacocat'.substring(4, 3) == ''","evalError":{"errors":[{"message":"invalid substring range. start: 4, end: 3"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 4~int,\n 3~int\n )~string^string_substring_int_int,\n \"\"~string\n)~bool^equals","type":"bool"}]},{"name":"type_errors","tests":[{"original":{"name":"charat_invalid_type","expr":"42.charAt(2) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: found no matching overload for 'charAt' applied to 'int.(int)'\n | 42.charAt(2) == ''\n | .........^"},{"original":{"name":"charat_invalid_argument","expr":"'hello'.charAt(true) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"hello\"^#*expr.Constant_StringValue#.charAt(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:15: found no matching overload for 'charAt' applied to 'string.(bool)'\n | 'hello'.charAt(true) == ''\n | ..............^"},{"original":{"name":"indexof_unary_invalid_type","expr":"24.indexOf('2') == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 24^#*expr.Constant_Int64Value#.indexOf(\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string)'\n | 24.indexOf('2') == 0\n | ..........^"},{"original":{"name":"indexof_unary_invalid_argument","expr":"'hello'.indexOf(true) == 1","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"hello\"^#*expr.Constant_StringValue#.indexOf(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:16: found no matching overload for 'indexOf' applied to 'string.(bool)'\n | 'hello'.indexOf(true) == 1\n | ...............^"},{"original":{"name":"indexof_binary_invalid_argument","expr":"42.indexOf('4', 0) == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.indexOf(\n \"4\"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string, int)'\n | 42.indexOf('4', 0) == 0\n | ..........^"},{"original":{"name":"indexof_binary_invalid_argument_2","expr":"'42'.indexOf(4, 0) == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.indexOf(\n 4^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(int, int)'\n | '42'.indexOf(4, 0) == 0\n | ............^"},{"original":{"name":"indexof_binary_both_invalid_arguments","expr":"'42'.indexOf('4', '0') == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.indexOf(\n \"4\"^#*expr.Constant_StringValue#,\n \"0\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, string)'\n | '42'.indexOf('4', '0') == 0\n | ............^"},{"original":{"name":"indexof_ternary_invalid_arguments","expr":"'42'.indexOf('4', 0, 1) == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.indexOf(\n \"4\"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, int, int)'\n | '42'.indexOf('4', 0, 1) == 0\n | ............^"},{"original":{"name":"split_invalid_type","expr":"42.split('2') == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.split(\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('2') == ['4']\n | ........^"},{"original":{"name":"replace_invalid_type","expr":"42.replace(2, 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(int, int)'\n | 42.replace(2, 1) == '41'\n | ..........^"},{"original":{"name":"replace_binary_invalid_argument","expr":"'42'.replace(2, 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, int)'\n | '42'.replace(2, 1) == '41'\n | ............^"},{"original":{"name":"replace_binary_invalid_argument_2","expr":"'42'.replace('2', 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int)'\n | '42'.replace('2', 1) == '41'\n | ............^"},{"original":{"name":"replace_ternary_invalid_argument","expr":"42.replace('2', '1', 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(string, string, int)'\n | 42.replace('2', '1', 1) == '41'\n | ..........^"},{"original":{"name":"replace_ternary_invalid_argument_2","expr":"'42'.replace(2, '1', 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n \"1\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, string, int)'\n | '42'.replace(2, '1', 1) == '41'\n | ............^"},{"original":{"name":"replace_ternary_invalid_argument_3","expr":"'42'.replace('2', 1, 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int, int)'\n | '42'.replace('2', 1, 1) == '41'\n | ............^"},{"original":{"name":"replace_ternary_invalid_argument_4","expr":"'42'.replace('2', '1', '1') == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, string)'\n | '42'.replace('2', '1', '1') == '41'\n | ............^"},{"original":{"name":"replace_quaternary_invalid_argument","expr":"'42'.replace('2', '1', 1, false) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, int, bool)'\n | '42'.replace('2', '1', 1, false) == '41'\n | ............^"},{"original":{"name":"split_invalid_type_empty_arg","expr":"42.split('') == ['4', '2']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.split(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('') == ['4', '2']\n | ........^"},{"original":{"name":"split_invalid_argument","expr":"'42'.split(2) == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int)'\n | '42'.split(2) == ['4']\n | ..........^"},{"original":{"name":"split_binary_invalid_type","expr":"42.split('2', '1') == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.split(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string, string)'\n | 42.split('2', '1') == ['4']\n | ........^"},{"original":{"name":"split_binary_invalid_argument","expr":"'42'.split(2, 1) == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int, int)'\n | '42'.split(2, 1) == ['4']\n | ..........^"},{"original":{"name":"split_binary_invalid_argument_2","expr":"'42'.split('2', '1') == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, string)'\n | '42'.split('2', '1') == ['4']\n | ..........^"},{"original":{"name":"split_ternary_invalid_argument","expr":"'42'.split('2', 1, 1) == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, int, int)'\n | '42'.split('2', 1, 1) == ['4']\n | ..........^"},{"original":{"name":"substring_ternary_invalid_argument","expr":"'hello'.substring(1, 2, 3) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"hello\"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: found no matching overload for 'substring' applied to 'string.(int, int, int)'\n | 'hello'.substring(1, 2, 3) == ''\n | .................^"},{"original":{"name":"substring_binary_invalid_type","expr":"30.substring(true, 3) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 30^#*expr.Constant_Int64Value#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'substring' applied to 'int.(bool, int)'\n | 30.substring(true, 3) == ''\n | ............^"},{"original":{"name":"substring_binary_invalid_argument","expr":"'tacocat'.substring(true, 3) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(bool, int)'\n | 'tacocat'.substring(true, 3) == ''\n | ...................^"},{"original":{"name":"substring_binary_invalid_argument_2","expr":"'tacocat'.substring(0, false) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(int, bool)'\n | 'tacocat'.substring(0, false) == ''\n | ...................^"}]}]},{"name":"timestamps","suites":[{"name":"timestamp_conversions","tests":[{"original":{"name":"toInt_timestamp","expr":"int(timestamp('2009-02-13T23:31:30Z'))","value":{"int64Value":"1234567890"}},"ast":"int(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64","type":"int"},{"original":{"name":"toString_timestamp","expr":"string(timestamp('2009-02-13T23:31:30Z'))","value":{"stringValue":"2009-02-13T23:31:30Z"}},"ast":"string(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string","type":"string"},{"original":{"name":"toString_timestamp_nanos","expr":"string(timestamp('9999-12-31T23:59:59.999999999Z'))","value":{"stringValue":"9999-12-31T23:59:59.999999999Z"}},"ast":"string(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string","type":"string"},{"original":{"name":"toType_timestamp","expr":"type(timestamp('2009-02-13T23:31:30Z'))","value":{"typeValue":"google.protobuf.Timestamp"}},"ast":"type(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~type(timestamp)^type","type":"type(timestamp)"},{"original":{"name":"type_comparison","expr":"google.protobuf.Timestamp == type(timestamp('2009-02-13T23:31:30Z'))","value":{"boolValue":true}},"ast":"_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Timestamp^#*expr.Expr_SelectExpr#,\n type(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Timestamp~type(timestamp)^google.protobuf.Timestamp,\n type(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n )~type(timestamp)^type\n)~bool^equals","type":"bool"}]},{"name":"duration_conversions","tests":[{"original":{"name":"toString_duration","expr":"string(duration('1000000s'))","value":{"stringValue":"1000000s"}},"ast":"string(\n duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n)~string^duration_to_string","type":"string"},{"original":{"name":"toType_duration","expr":"type(duration('1000000s'))","value":{"typeValue":"google.protobuf.Duration"}},"ast":"type(\n duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n)~type(duration)^type","type":"type(duration)"},{"original":{"name":"type_comparison","expr":"google.protobuf.Duration == type(duration('1000000s'))","value":{"boolValue":true}},"ast":"_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Duration^#*expr.Expr_SelectExpr#,\n type(\n duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Duration~type(duration)^google.protobuf.Duration,\n type(\n duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n )~type(duration)^type\n)~bool^equals","type":"bool"}]},{"name":"timestamp_selectors","tests":[{"original":{"name":"getDate","expr":"timestamp('2009-02-13T23:31:30Z').getDate()","value":{"int64Value":"13"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDate()~int^timestamp_to_day_of_month_1_based","type":"int"},{"original":{"name":"getDayOfMonth","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfMonth()","value":{"int64Value":"12"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth()~int^timestamp_to_day_of_month","type":"int"},{"original":{"name":"getDayOfWeek","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfWeek()","value":{"int64Value":"5"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfWeek()~int^timestamp_to_day_of_week","type":"int"},{"original":{"name":"getDayOfYear","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfYear()","value":{"int64Value":"43"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfYear()~int^timestamp_to_day_of_year","type":"int"},{"original":{"name":"getFullYear","expr":"timestamp('2009-02-13T23:31:30Z').getFullYear()","value":{"int64Value":"2009"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getFullYear()~int^timestamp_to_year","type":"int"},{"original":{"name":"getHours","expr":"timestamp('2009-02-13T23:31:30Z').getHours()","value":{"int64Value":"23"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getHours()~int^timestamp_to_hours","type":"int"},{"original":{"name":"getMilliseconds","expr":"timestamp('2009-02-13T23:31:20.123456789Z').getMilliseconds()","value":{"int64Value":"123"}},"ast":"timestamp(\n \"2009-02-13T23:31:20.123456789Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMilliseconds()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:20.123456789Z\"~string\n)~timestamp^string_to_timestamp.getMilliseconds()~int^timestamp_to_milliseconds","type":"int"},{"original":{"name":"getMinutes","expr":"timestamp('2009-02-13T23:31:30Z').getMinutes()","value":{"int64Value":"31"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMinutes()~int^timestamp_to_minutes","type":"int"},{"original":{"name":"getMonth","expr":"timestamp('2009-02-13T23:31:30Z').getMonth()","value":{"int64Value":"1"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMonth()~int^timestamp_to_month","type":"int"},{"original":{"name":"getSeconds","expr":"timestamp('2009-02-13T23:31:30Z').getSeconds()","value":{"int64Value":"30"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getSeconds()~int^timestamp_to_seconds","type":"int"}]},{"name":"timestamp_selectors_tz","tests":[{"original":{"name":"getDate","expr":"timestamp('2009-02-13T23:31:30Z').getDate('Australia/Sydney')","value":{"int64Value":"14"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate(\n \"Australia/Sydney\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDate(\n \"Australia/Sydney\"~string\n)~int^timestamp_to_day_of_month_1_based_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_name_pos","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfMonth('US/Central')","value":{"int64Value":"12"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"US/Central\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"US/Central\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_numerical_pos","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfMonth('+11:00')","value":{"int64Value":"13"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"+11:00\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"+11:00\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_numerical_neg","expr":"timestamp('2009-02-13T02:00:00Z').getDayOfMonth('-02:30')","value":{"int64Value":"11"}},"ast":"timestamp(\n \"2009-02-13T02:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"-02:30\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T02:00:00Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"-02:30\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_name_neg","expr":"timestamp('2009-02-13T02:00:00Z').getDayOfMonth('America/St_Johns')","value":{"int64Value":"11"}},"ast":"timestamp(\n \"2009-02-13T02:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"America/St_Johns\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T02:00:00Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"America/St_Johns\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfWeek","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfWeek('UTC')","value":{"int64Value":"5"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek(\n \"UTC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfWeek(\n \"UTC\"~string\n)~int^timestamp_to_day_of_week_with_tz","type":"int"},{"original":{"name":"getDayOfYear","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfYear('US/Central')","value":{"int64Value":"43"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear(\n \"US/Central\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfYear(\n \"US/Central\"~string\n)~int^timestamp_to_day_of_year_with_tz","type":"int"},{"original":{"name":"getFullYear","expr":"timestamp('2009-02-13T23:31:30Z').getFullYear('-09:30')","value":{"int64Value":"2009"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear(\n \"-09:30\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getFullYear(\n \"-09:30\"~string\n)~int^timestamp_to_year_with_tz","type":"int"},{"original":{"name":"getHours","expr":"timestamp('2009-02-13T23:31:30Z').getHours('02:00')","value":{"int64Value":"1"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours(\n \"02:00\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getHours(\n \"02:00\"~string\n)~int^timestamp_to_hours_with_tz","type":"int"},{"original":{"name":"getMinutes","expr":"timestamp('2009-02-13T23:31:30Z').getMinutes('Asia/Kathmandu')","value":{"int64Value":"16"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes(\n \"Asia/Kathmandu\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMinutes(\n \"Asia/Kathmandu\"~string\n)~int^timestamp_to_minutes_with_tz","type":"int"},{"original":{"name":"getMonth","expr":"timestamp('2009-02-13T23:31:30Z').getMonth('UTC')","value":{"int64Value":"1"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth(\n \"UTC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMonth(\n \"UTC\"~string\n)~int^timestamp_to_month_with_tz","type":"int"},{"original":{"name":"getSeconds","expr":"timestamp('2009-02-13T23:31:30Z').getSeconds('-00:00')","value":{"int64Value":"30"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds(\n \"-00:00\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getSeconds(\n \"-00:00\"~string\n)~int^timestamp_to_seconds_tz","type":"int"}]},{"name":"timestamp_equality","tests":[{"original":{"name":"eq_same","expr":"timestamp('2009-02-13T23:31:30Z') == timestamp('2009-02-13T23:31:30Z')","value":{"boolValue":true}},"ast":"_==_(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"eq_diff","expr":"timestamp('2009-02-13T23:31:29Z') == timestamp('2009-02-13T23:31:30Z')","value":{"boolValue":false}},"ast":"_==_(\n timestamp(\n \"2009-02-13T23:31:29Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n timestamp(\n \"2009-02-13T23:31:29Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"neq_same","expr":"timestamp('1945-05-07T02:41:00Z') != timestamp('1945-05-07T02:41:00Z')","value":{"boolValue":false}},"ast":"_!=_(\n timestamp(\n \"1945-05-07T02:41:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"1945-05-07T02:41:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n timestamp(\n \"1945-05-07T02:41:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"1945-05-07T02:41:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals","type":"bool"},{"original":{"name":"neq_diff","expr":"timestamp('2000-01-01T00:00:00Z') != timestamp('2001-01-01T00:00:00Z')","value":{"boolValue":true}},"ast":"_!=_(\n timestamp(\n \"2000-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n timestamp(\n \"2000-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals","type":"bool"}]},{"name":"duration_equality","tests":[{"original":{"name":"eq_same","expr":"duration('123s') == duration('123s')","value":{"boolValue":true}},"ast":"_==_(\n duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n duration(\n \"123s\"~string\n )~duration^string_to_duration,\n duration(\n \"123s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"eq_diff","expr":"duration('60s') == duration('3600s')","value":{"boolValue":false}},"ast":"_==_(\n duration(\n \"60s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"3600s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n duration(\n \"60s\"~string\n )~duration^string_to_duration,\n duration(\n \"3600s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"neq_same","expr":"duration('604800s') != duration('604800s')","value":{"boolValue":false}},"ast":"_!=_(\n duration(\n \"604800s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"604800s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n duration(\n \"604800s\"~string\n )~duration^string_to_duration,\n duration(\n \"604800s\"~string\n )~duration^string_to_duration\n)~bool^not_equals","type":"bool"},{"original":{"name":"neq_diff","expr":"duration('86400s') != duration('86164s')","value":{"boolValue":true}},"ast":"_!=_(\n duration(\n \"86400s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"86164s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n duration(\n \"86400s\"~string\n )~duration^string_to_duration,\n duration(\n \"86164s\"~string\n )~duration^string_to_duration\n)~bool^not_equals","type":"bool"}]},{"name":"timestamp_arithmetic","tests":[{"original":{"name":"add_duration_to_time","expr":"timestamp('2009-02-13T23:00:00Z') + duration('240s') == timestamp('2009-02-13T23:04:00Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"240s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:04:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"240s\"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n \"2009-02-13T23:04:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"add_time_to_duration","expr":"duration('120s') + timestamp('2009-02-13T23:01:00Z') == timestamp('2009-02-13T23:03:00Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n duration(\n \"120s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:01:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:03:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n duration(\n \"120s\"~string\n )~duration^string_to_duration,\n timestamp(\n \"2009-02-13T23:01:00Z\"~string\n )~timestamp^string_to_timestamp\n )~timestamp^add_duration_timestamp,\n timestamp(\n \"2009-02-13T23:03:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"add_duration_to_duration","expr":"duration('600s') + duration('50s') == duration('650s')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n duration(\n \"600s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"50s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"650s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n duration(\n \"600s\"~string\n )~duration^string_to_duration,\n duration(\n \"50s\"~string\n )~duration^string_to_duration\n )~duration^add_duration_duration,\n duration(\n \"650s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"add_time_to_duration_nanos_negative","expr":"timestamp('0001-01-01T00:00:01.000000001Z') + duration('-999999999ns') == timestamp('0001-01-01T00:00:00.000000002Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.000000001Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-999999999ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"0001-01-01T00:00:00.000000002Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.000000001Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"-999999999ns\"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n \"0001-01-01T00:00:00.000000002Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"add_time_to_duration_nanos_positive","expr":"timestamp('0001-01-01T00:00:01.999999999Z') + duration('999999999ns') == timestamp('0001-01-01T00:00:02.999999998Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"999999999ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"0001-01-01T00:00:02.999999998Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.999999999Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"999999999ns\"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n \"0001-01-01T00:00:02.999999998Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"subtract_duration_from_time","expr":"timestamp('2009-02-13T23:10:00Z') - duration('600s') == timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:10:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"600s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:10:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"600s\"~string\n )~duration^string_to_duration\n )~timestamp^subtract_timestamp_duration,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"subtract_time_from_time","expr":"timestamp('2009-02-13T23:31:00Z') - timestamp('2009-02-13T23:29:00Z') == duration('120s')","value":{"boolValue":true}},"ast":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:31:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:29:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"120s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:31:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:29:00Z\"~string\n )~timestamp^string_to_timestamp\n )~duration^subtract_timestamp_timestamp,\n duration(\n \"120s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"subtract_duration_from_duration","expr":"duration('900s') - duration('42s') == duration('858s')","value":{"boolValue":true}},"ast":"_==_(\n _-_(\n duration(\n \"900s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"42s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"858s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _-_(\n duration(\n \"900s\"~string\n )~duration^string_to_duration,\n duration(\n \"42s\"~string\n )~duration^string_to_duration\n )~duration^subtract_duration_duration,\n duration(\n \"858s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"}]},{"name":"comparisons","tests":[{"original":{"name":"leq_timestamp_true","expr":"timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp","type":"bool"},{"original":{"name":"leq_timestamp_false","expr":"timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T22:59:59Z')","value":{"boolValue":false}},"ast":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T22:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T22:59:59Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp","type":"bool"},{"original":{"name":"leq_duration_true","expr":"duration('200s') \u003c= duration('200s')","value":{"boolValue":true}},"ast":"_\u003c=_(\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n duration(\n \"200s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration","type":"bool"},{"original":{"name":"leq_duration_false","expr":"duration('300s') \u003c= duration('200s')","value":{"boolValue":false}},"ast":"_\u003c=_(\n duration(\n \"300s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n duration(\n \"300s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration","type":"bool"},{"original":{"name":"less_timestamp_true","expr":"timestamp('2009-02-13T23:00:00Z') \u003c timestamp('2009-03-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003c_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-03-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-03-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^less_timestamp","type":"bool"},{"original":{"name":"less_duration_true","expr":"duration('200s') \u003c duration('300s')","value":{"boolValue":true}},"ast":"_\u003c_(\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"300s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n duration(\n \"200s\"~string\n )~duration^string_to_duration,\n duration(\n \"300s\"~string\n )~duration^string_to_duration\n)~bool^less_duration","type":"bool"},{"original":{"name":"geq_timestamp_true","expr":"timestamp('2009-02-13T23:00:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003e=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp","type":"bool"},{"original":{"name":"geq_timestamp_false","expr":"timestamp('2009-02-13T22:58:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":false}},"ast":"_\u003e=_(\n timestamp(\n \"2009-02-13T22:58:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n timestamp(\n \"2009-02-13T22:58:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp","type":"bool"},{"original":{"name":"geq_duration_true","expr":"duration('200s') \u003e= duration('200s')","value":{"boolValue":true}},"ast":"_\u003e=_(\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n duration(\n \"200s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration","type":"bool"},{"original":{"name":"geq_duration_false","expr":"duration('120s') \u003e= duration('200s')","value":{"boolValue":false}},"ast":"_\u003e=_(\n duration(\n \"120s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n duration(\n \"120s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration","type":"bool"},{"original":{"name":"greater_timestamp_true","expr":"timestamp('2009-02-13T23:59:00Z') \u003e timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003e_(\n timestamp(\n \"2009-02-13T23:59:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n timestamp(\n \"2009-02-13T23:59:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_timestamp","type":"bool"},{"original":{"name":"greater_duration_true","expr":"duration('300s') \u003e duration('200s')","value":{"boolValue":true}},"ast":"_\u003e_(\n duration(\n \"300s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n duration(\n \"300s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^greater_duration","type":"bool"}]},{"name":"duration_converters","tests":[{"original":{"name":"get_hours","expr":"duration('10000s').getHours()","value":{"int64Value":"2"}},"ast":"duration(\n \"10000s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"10000s\"~string\n)~duration^string_to_duration.getHours()~int^duration_to_hours","type":"int"},{"original":{"name":"get_milliseconds","description":"Obtain the milliseconds component of the duration. Note, this is not the same as converting the duration to milliseconds. This behavior will be deprecated.","expr":"x.getMilliseconds()","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Duration"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Duration","value":"123.321456789s"}}}},"value":{"int64Value":"321"}},"ast":"x^#*expr.Expr_IdentExpr#.getMilliseconds()^#*expr.Expr_CallExpr#","checkedAst":"x~duration^x.getMilliseconds()~int^duration_to_milliseconds","type":"int"},{"original":{"name":"get_minutes","expr":"duration('3730s').getMinutes()","value":{"int64Value":"62"}},"ast":"duration(\n \"3730s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"3730s\"~string\n)~duration^string_to_duration.getMinutes()~int^duration_to_minutes","type":"int"},{"original":{"name":"get_seconds","expr":"duration('3730s').getSeconds()","value":{"int64Value":"3730"}},"ast":"duration(\n \"3730s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"3730s\"~string\n)~duration^string_to_duration.getSeconds()~int^duration_to_seconds","type":"int"}]},{"name":"timestamp_range","tests":[{"original":{"name":"from_string_under","expr":"timestamp('0000-01-01T00:00:00Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"timestamp(\n \"0000-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"0000-01-01T00:00:00Z\"~string\n)~timestamp^string_to_timestamp","type":"timestamp"},{"original":{"name":"from_string_over","expr":"timestamp('10000-01-01T00:00:00Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"timestamp(\n \"10000-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"10000-01-01T00:00:00Z\"~string\n)~timestamp^string_to_timestamp","type":"timestamp"},{"original":{"name":"add_duration_under","expr":"timestamp('0001-01-01T00:00:00Z') + duration('-1s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-1s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"-1s\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"add_duration_over","expr":"timestamp('9999-12-31T23:59:59Z') + duration('1s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"9999-12-31T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"1s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"9999-12-31T23:59:59Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"1s\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"add_duration_nanos_over","expr":"timestamp('9999-12-31T23:59:59.999999999Z') + duration('1ns')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"1ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"1ns\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"add_duration_nanos_under","expr":"timestamp('0001-01-01T00:00:00Z') + duration('-1ns')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-1ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"-1ns\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"sub_time_duration_over","expr":"timestamp('9999-12-31T23:59:59Z') - timestamp('0001-01-01T00:00:00Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n timestamp(\n \"9999-12-31T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n timestamp(\n \"9999-12-31T23:59:59Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp","type":"duration"},{"original":{"name":"sub_time_duration_under","expr":"timestamp('0001-01-01T00:00:00Z') - timestamp('9999-12-31T23:59:59Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"9999-12-31T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"9999-12-31T23:59:59Z\"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp","type":"duration"}]},{"name":"duration_range","tests":[{"original":{"name":"from_string_under","expr":"duration('-320000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"duration(\n \"-320000000000s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"-320000000000s\"~string\n)~duration^string_to_duration","type":"duration"},{"original":{"name":"from_string_over","expr":"duration('320000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"duration(\n \"320000000000s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"320000000000s\"~string\n)~duration^string_to_duration","type":"duration"},{"original":{"name":"add_under","expr":"duration('-200000000000s') + duration('-200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration","type":"duration"},{"original":{"name":"add_over","expr":"duration('200000000000s') + duration('200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration","type":"duration"},{"original":{"name":"sub_under","expr":"duration('-200000000000s') - duration('200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration","type":"duration"},{"original":{"name":"sub_over","expr":"duration('200000000000s') - duration('-200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration","type":"duration"}]}]},{"name":"type_deductions","suites":[{"name":"constant_literals","tests":[{"original":{"name":"bool","expr":"true","typedResult":{"result":{"boolValue":true},"deducedType":{"primitive":"BOOL"}}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"int","expr":"42","typedResult":{"result":{"int64Value":"42"},"deducedType":{"primitive":"INT64"}}},"ast":"42^#*expr.Constant_Int64Value#","checkedAst":"42~int","type":"int"},{"original":{"name":"uint","expr":"42u","typedResult":{"result":{"uint64Value":"42"},"deducedType":{"primitive":"UINT64"}}},"ast":"42u^#*expr.Constant_Uint64Value#","checkedAst":"42u~uint","type":"uint"},{"original":{"name":"double","expr":"0.1","typedResult":{"result":{"doubleValue":0.1},"deducedType":{"primitive":"DOUBLE"}}},"ast":"0.1^#*expr.Constant_DoubleValue#","checkedAst":"0.1~double","type":"double"},{"original":{"name":"string","expr":"\"test\"","typedResult":{"result":{"stringValue":"test"},"deducedType":{"primitive":"STRING"}}},"ast":"\"test\"^#*expr.Constant_StringValue#","checkedAst":"\"test\"~string","type":"string"},{"original":{"name":"bytes","expr":"b\"test\"","typedResult":{"result":{"bytesValue":"dGVzdA=="},"deducedType":{"primitive":"BYTES"}}},"ast":"b\"test\"^#*expr.Constant_BytesValue#","checkedAst":"b\"test\"~bytes","type":"bytes"},{"original":{"name":"null","expr":"null","typedResult":{"result":{"nullValue":null},"deducedType":{"null":null}}},"ast":"null^#*expr.Constant_NullValue#","checkedAst":"null~null","type":"null"}]},{"name":"complex_initializers","tests":[{"original":{"name":"list","expr":"[1]","typedResult":{"result":{"listValue":{"values":[{"int64Value":"1"}]}},"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"[\n 1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n 1~int\n]~list(int)","type":"list(int)"},{"original":{"name":"map","expr":"{'abc': 123}","typedResult":{"result":{"mapValue":{"entries":[{"key":{"stringValue":"abc"},"value":{"int64Value":"123"}}]}},"deducedType":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"INT64"}}}}},"ast":"{\n \"abc\"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"{\n \"abc\"~string:123~int\n}~map(string, int)","type":"map(string, int)"},{"original":{"name":"struct","expr":"TestAllTypes{single_int64: 1}","container":"cel.expr.conformance.proto3","typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"1"}},"deducedType":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}},"ast":"TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"field_access","tests":[{"original":{"name":"int_field","expr":"TestAllTypes{single_int64: 1}.single_int64","container":"cel.expr.conformance.proto3","typedResult":{"result":{"int64Value":"1"},"deducedType":{"primitive":"INT64"}}},"ast":"TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int","type":"int"},{"original":{"name":"repeated_int_field","expr":"TestAllTypes{}.repeated_int64","container":"cel.expr.conformance.proto3","typedResult":{"result":{"listValue":{}},"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)","type":"list(int)"},{"original":{"name":"map_bool_int","expr":"TestAllTypes{}.map_bool_int64","container":"cel.expr.conformance.proto3","typedResult":{"result":{"mapValue":{}},"deducedType":{"mapType":{"keyType":{"primitive":"BOOL"},"valueType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_bool_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_bool_int64~map(bool, int)","type":"map(bool, int)"},{"original":{"name":"enum_field","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto3","typedResult":{"result":{"int64Value":"0"},"deducedType":{"primitive":"INT64"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"repeated_enum_field","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto3","typedResult":{"result":{"listValue":{}},"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"enum_map_field","expr":"TestAllTypes{}.map_int32_enum","container":"cel.expr.conformance.proto3","typedResult":{"result":{"mapValue":{}},"deducedType":{"mapType":{"keyType":{"primitive":"INT64"},"valueType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_int32_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_int32_enum~map(int, int)","type":"map(int, int)"}]},{"name":"indexing","tests":[{"original":{"name":"list","expr":"['foo'][0]","typedResult":{"result":{"stringValue":"foo"},"deducedType":{"primitive":"STRING"}}},"ast":"_[_](\n [\n \"foo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n \"foo\"~string\n ]~list(string),\n 0~int\n)~string^index_list","type":"string"},{"original":{"name":"map","expr":"{'abc': 123}['abc']","typedResult":{"result":{"int64Value":"123"},"deducedType":{"primitive":"INT64"}}},"ast":"_[_](\n {\n \"abc\"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"abc\"~string:123~int\n }~map(string, int),\n \"abc\"~string\n)~int^index_map","type":"int"}]},{"name":"functions","tests":[{"original":{"name":"nested_calls","expr":"('foo' + 'bar').startsWith('foo')","typedResult":{"result":{"boolValue":true},"deducedType":{"primitive":"BOOL"}}},"ast":"_+_(\n \"foo\"^#*expr.Constant_StringValue#,\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.startsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"foo\"~string,\n \"bar\"~string\n)~string^add_string.startsWith(\n \"foo\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"function_result_type","expr":"fn('abc', 123)","checkOnly":true,"typeEnv":[{"name":"fn","function":{"overloads":[{"overloadId":"fn_string_int","params":[{"primitive":"STRING"},{"primitive":"INT64"}],"resultType":{"primitive":"STRING"}}]}}],"typedResult":{"deducedType":{"primitive":"STRING"}}},"ast":"fn(\n \"abc\"^#*expr.Constant_StringValue#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"fn(\n \"abc\"~string,\n 123~int\n)~string^fn_string_int","type":"string"}]},{"name":"flexible_type_parameter_assignment","tests":[{"original":{"name":"list_parameter","expr":"[[], [[]], [[[]]], [[[[]]]]]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"dyn":{}}}}}}}}}}}}}},"ast":"[\n []^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n []~list(list(list(list(dyn)))),\n [\n []~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))","type":"list(list(list(list(list(dyn)))))"},{"original":{"name":"list_parameter_order_independent","expr":"[[[[[]]]], [], [[[]]]]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"dyn":{}}}}}}}}}}}}}},"ast":"[\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n []~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))","type":"list(list(list(list(list(dyn)))))"},{"original":{"name":"comprehension_type_var_aliasing","expr":"msg.repeated_nested_message.map(x, x).map(y, y.bb)","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n y^#*expr.Expr_IdentExpr#.bb^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result,\n [\n x~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^x\n ]~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n // Result\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result)~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n y~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^y.bb~int\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"overload_type_var_aliasing","expr":"([] + msg.repeated_nested_message + [])[0].bb","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"primitive":"INT64"}}},"ast":"_[_](\n _+_(\n _+_(\n []^#*expr.Expr_ListExpr#,\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.bb^#*expr.Expr_SelectExpr#","checkedAst":"_[_](\n _+_(\n _+_(\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n 0~int\n)~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^index_list.bb~int","type":"int"},{"original":{"name":"unconstrained_type_var_as_dyn","expr":"([].map(x,x))[0].foo","checkOnly":true,"typedResult":{"deducedType":{"dyn":{}}}},"ast":"_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.foo^#*expr.Expr_SelectExpr#","checkedAst":"_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []~list(dyn),\n // Accumulator\n @result,\n // Init\n []~list(dyn),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(dyn)^@result,\n [\n x~dyn^x\n ]~list(dyn)\n )~list(dyn)^add_list,\n // Result\n @result~list(dyn)^@result)~list(dyn),\n 0~int\n)~dyn^index_list.foo~dyn","type":"dyn"},{"original":{"name":"list_parameters_do_not_unify","expr":"[msg.single_int64_wrapper, msg.single_string_wrapper]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"dyn":{}}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_string_wrapper~wrapper(string)\n]~list(dyn)","type":"list(dyn)"},{"original":{"name":"optional_none","expr":"[optional.none(), optional.of(1)]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"primitive":"INT64"}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(int))","type":"list(optional_type(int))"},{"original":{"name":"optional_none_2","expr":"[optional.of(1), optional.none()]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"primitive":"INT64"}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n]~list(optional_type(int))","type":"list(optional_type(int))"},{"original":{"name":"optional_dyn_promotion","expr":"[optional.of(1), optional.of(dyn(1))]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"dyn":{}}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of\n]~list(optional_type(dyn))","type":"list(optional_type(dyn))"},{"original":{"name":"optional_dyn_promotion_2","expr":"[optional.of(dyn(1)), optional.of(1)]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"dyn":{}}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(dyn))","type":"list(optional_type(dyn))"},{"original":{"name":"optional_in_ternary","expr":"true ? optional.of(dyn(1)) : optional.of(1)","checkOnly":true,"typedResult":{"deducedType":{"abstractType":{"name":"optional_type","parameterTypes":[{"dyn":{}}]}}}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~optional_type(dyn)^conditional","type":"optional_type(dyn)"}]},{"name":"wrappers","tests":[{"original":{"name":"wrapper_promotion","expr":"[msg.single_int64_wrapper, msg.single_int64]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"wrapper":"INT64"}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(wrapper(int))","type":"list(wrapper(int))"},{"original":{"name":"wrapper_promotion_2","expr":"[msg.single_int64, msg.single_int64_wrapper]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"wrapper":"INT64"}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int)\n]~list(int)","type":"list(int)"},{"original":{"name":"wrapper_dyn_promotion","expr":"[msg.single_int64_wrapper, msg.single_int64, dyn(1)]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"dyn":{}}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n dyn(\n 1~int\n )~dyn^to_dyn\n]~list(dyn)","type":"list(dyn)"},{"original":{"name":"wrapper_dyn_promotion_2","expr":"[dyn(1), msg.single_int64_wrapper, msg.single_int64]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"dyn":{}}}}}},"ast":"[\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n dyn(\n 1~int\n )~dyn^to_dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(dyn)","type":"list(dyn)"},{"original":{"name":"wrapper_primitive_assignable","expr":"msg.single_int64_wrapper + 1","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"primitive":"INT64"}}},"ast":"_+_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 1~int\n)~int^add_int64","type":"int"},{"original":{"name":"wrapper_null_assignable","expr":"msg.single_int64_wrapper == null","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"primitive":"BOOL"}}},"ast":"_==_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"wrapper_ternary_parameter_assignment","expr":"false ? msg.single_int64_wrapper : null","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"wrapper":"INT64"}}},"ast":"_?_:_(\n false^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n false~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~wrapper(int)^conditional","type":"wrapper(int)"},{"original":{"name":"wrapper_ternary_parameter_assignment_2","expr":"true ? msg.single_int64_wrapper : 42","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"wrapper":"INT64"}}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 42~int\n)~wrapper(int)^conditional","type":"wrapper(int)"}]},{"name":"type_parameters","tests":[{"original":{"name":"multiple_parameters_generality","expr":"[tuple(1, 2u, 3.0), tuple(dyn(1), dyn(2u), dyn(3.0))][0]","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}}],"typedResult":{"deducedType":{"abstractType":{"name":"tuple","parameterTypes":[{"dyn":{}},{"dyn":{}},{"dyn":{}}]}}}},"ast":"_[_](\n [\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(dyn, dyn, dyn)^tuple_T_U_V\n ]~list(tuple(dyn, dyn, dyn)),\n 0~int\n)~tuple(dyn, dyn, dyn)^index_list","type":"tuple(dyn, dyn, dyn)"},{"original":{"name":"multiple_parameters_generality_2","expr":"sort(tuple(dyn(1), 2u, 3.0))","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}},{"name":"sort","function":{"overloads":[{"overloadId":"sort_tuple_T_T_T","params":[{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"T"},{"typeParam":"T"}]}}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"T"},{"typeParam":"T"}]}}}]}}],"typedResult":{"deducedType":{"abstractType":{"name":"tuple","parameterTypes":[{"dyn":{}},{"dyn":{}},{"dyn":{}}]}}}},"ast":"sort(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"sort(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint,\n 3~double\n )~tuple(dyn, uint, double)^tuple_T_U_V\n)~tuple(dyn, dyn, dyn)^sort_tuple_T_T_T","type":"tuple(dyn, dyn, dyn)"},{"original":{"name":"multiple_parameters_parameterized_ovl","expr":"tuple(1, 2u, 3.0) == tuple(1, dyn(2u), dyn(3.0))","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}}],"typedResult":{"deducedType":{"primitive":"BOOL"}}},"ast":"_==_(\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n 1~int,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(int, dyn, dyn)^tuple_T_U_V\n)~bool^equals","type":"bool"},{"original":{"name":"multiple_parameters_parameterized_ovl_2","expr":"tuple(dyn(1), dyn(2u), 3.0) == tuple(1, 2u, 3.0)","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}}],"typedResult":{"deducedType":{"primitive":"BOOL"}}},"ast":"_==_(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 3~double\n )~tuple(dyn, dyn, double)^tuple_T_U_V,\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V\n)~bool^equals","type":"bool"}]},{"name":"legacy_nullable_types","tests":[{"original":{"name":"null_assignable_to_message_parameter_candidate","expr":"[msg, null][0]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}}}},"typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}},"deducedType":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}},"ast":"_[_](\n [\n msg^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"},{"original":{"name":"null_assignable_to_duration_parameter_candidate","expr":"[msg.single_duration, null][0]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}}}},"typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Duration","value":"0s"}},"deducedType":{"wellKnown":"DURATION"}}},"ast":"_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_duration^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_duration~duration,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"},{"original":{"name":"null_assignable_to_timestamp_parameter_candidate","expr":"[msg.single_timestamp, null][0]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}}}},"typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Timestamp","value":"1970-01-01T00:00:00Z"}},"deducedType":{"wellKnown":"TIMESTAMP"}}},"ast":"_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_timestamp^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_timestamp~timestamp,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"},{"original":{"name":"null_assignable_to_abstract_parameter_candidate","expr":"[optional.of(1), null][0]","checkOnly":true,"typedResult":{"deducedType":{"abstractType":{"name":"optional_type","parameterTypes":[{"primitive":"INT64"}]}}}},"ast":"_[_](\n [\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"}]}]},{"name":"unknowns"},{"name":"wrappers","suites":[{"name":"bool","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.BoolValue{value: true}}.single_any","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.BoolValue{value: true}}.single_value","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_bool_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_bool_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"int32","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.Int32Value{value: 1}}.single_any","container":"cel.expr.conformance.proto3","value":{"int64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.Int32Value{value: 1}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_int32_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"int64","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.Int64Value{value: 1}}.single_any","container":"cel.expr.conformance.proto3","value":{"int64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json_number","expr":"TestAllTypes{single_value: google.protobuf.Int64Value{value: 1}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_json_string","expr":"TestAllTypes{single_value: google.protobuf.Int64Value{value: 9223372036854775807}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"9223372036854775807"}},"ast":"TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_int64_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"uint32","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.UInt32Value{value: 1u}}.single_any","container":"cel.expr.conformance.proto3","value":{"uint64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.UInt32Value{value: 1u}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_uint32_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_uint32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"uint64","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.UInt64Value{value: 1u}}.single_any","container":"cel.expr.conformance.proto3","value":{"uint64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json_number","expr":"TestAllTypes{single_value: google.protobuf.UInt64Value{value: 1u}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_json_string","expr":"TestAllTypes{single_value: google.protobuf.UInt64Value{value: 18446744073709551615u}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"18446744073709551615"}},"ast":"TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_uint64_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_uint64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"float","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.FloatValue{value: 1.0}}.single_any","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.FloatValue{value: 1.0}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_float_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_float_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"double","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.DoubleValue{value: 1.0}}.single_any","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.DoubleValue{value: 1.0}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_double_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_double_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"bytes","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.BytesValue{value: b'foo'}}.single_any","container":"cel.expr.conformance.proto3","value":{"bytesValue":"Zm9v"}},"ast":"TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b\"foo\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b\"foo\"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.BytesValue{value: b'foo'}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"Zm9v"}},"ast":"TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b\"foo\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b\"foo\"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_bytes_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_bytes_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"string","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.StringValue{value: 'foo'}}.single_any","container":"cel.expr.conformance.proto3","value":{"stringValue":"foo"}},"ast":"TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:\"foo\"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.StringValue{value: 'foo'}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"foo"}},"ast":"TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:\"foo\"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_string_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_string_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"value","tests":[{"original":{"name":"default_to_json","expr":"TestAllTypes{single_any: TestAllTypes{}.single_value}.single_any","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_any:TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"list_value","tests":[{"original":{"name":"literal_to_any","expr":"TestAllTypes{single_any: []}.single_any","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{\n single_any:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"struct","tests":[{"original":{"name":"literal_to_any","expr":"TestAllTypes{single_any: {}}.single_any","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_any:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"field_mask","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.FieldMask{paths: ['foo', 'bar']}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"foo,bar"}},"ast":"TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n \"foo\"^#*expr.Constant_StringValue#,\n \"bar\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n \"foo\"~string,\n \"bar\"~string\n ]~list(string)\n }~google.protobuf.FieldMask^google.protobuf.FieldMask\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"duration","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: duration('1000000s')}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"1000000s"}},"ast":"TestAllTypes{\n single_value:duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"timestamp","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: timestamp('9999-12-31T23:59:59.999999999Z')}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"9999-12-31T23:59:59.999999999Z"}},"ast":"TestAllTypes{\n single_value:timestamp(\n \"9999-12-31T23:59:59.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:timestamp(\n \"9999-12-31T23:59:59.999999999Z\"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"empty","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.Empty{}}.single_value","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_value:google.protobuf.Empty{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Empty{}~google.protobuf.Empty^google.protobuf.Empty\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]}]}]} as const; diff --git a/packages/cel/src/re2/CharClass.ts b/packages/cel/src/re2/CharClass.ts index 4c16f8d..7fb19d1 100644 --- a/packages/cel/src/re2/CharClass.ts +++ b/packages/cel/src/re2/CharClass.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from './RE2Flags' -import { Unicode } from './Unicode' -import { Utils } from './Utils' +import { RE2Flags } from './RE2Flags.js' +import { Unicode } from './Unicode.js' +import { Utils } from './Utils.js' /** * A "builder"-style helper class for manipulating character classes represented as an array of * pairs of runes [lo, hi], each denoting an inclusive interval. diff --git a/packages/cel/src/re2/Compiler.ts b/packages/cel/src/re2/Compiler.ts index 13110b9..1ae826e 100644 --- a/packages/cel/src/re2/Compiler.ts +++ b/packages/cel/src/re2/Compiler.ts @@ -1,10 +1,10 @@ -import { RE2Flags } from './RE2Flags' -import { Unicode } from './Unicode' -import { Utils } from './Utils' -import { Regexp } from './Regexp' -import { Inst } from './Inst' -import { Prog, PatchList } from './Prog' -import { RE2JSCompileException } from './exceptions' +import { RE2Flags } from './RE2Flags.js' +import { Unicode } from './Unicode.js' +import { Utils } from './Utils.js' +import { Regexp } from './Regexp.js' +import { Inst } from './Inst.js' +import { Prog, PatchList } from './Prog.js' +import { RE2JSCompileException } from './exceptions.js' /** * A fragment of a compiled regular expression program. diff --git a/packages/cel/src/re2/DFA.ts b/packages/cel/src/re2/DFA.ts index 86db58c..8cfc118 100644 --- a/packages/cel/src/re2/DFA.ts +++ b/packages/cel/src/re2/DFA.ts @@ -1,7 +1,7 @@ -import { Inst } from './Inst' -import { RE2Flags } from './RE2Flags' -import { Unicode } from './Unicode' -import { Utils } from './Utils' +import { Inst } from './Inst.js' +import { RE2Flags } from './RE2Flags.js' +import { Unicode } from './Unicode.js' +import { Utils } from './Utils.js' // FNV-1a 32-bit hash for an array of integers. const hashPCs = (pcs: Int32Array): number => { diff --git a/packages/cel/src/re2/Inst.ts b/packages/cel/src/re2/Inst.ts index cb3cec1..d9944b6 100644 --- a/packages/cel/src/re2/Inst.ts +++ b/packages/cel/src/re2/Inst.ts @@ -1,5 +1,5 @@ -import { RE2Flags } from './RE2Flags' -import { Unicode } from './Unicode' +import { RE2Flags } from './RE2Flags.js' +import { Unicode } from './Unicode.js' /** * A single instruction in the regular expression virtual machine. * diff --git a/packages/cel/src/re2/MachineInput.ts b/packages/cel/src/re2/MachineInput.ts index f8ef837..13bda9d 100644 --- a/packages/cel/src/re2/MachineInput.ts +++ b/packages/cel/src/re2/MachineInput.ts @@ -1,5 +1,5 @@ -import { Utils } from './Utils' -import { Unicode } from './Unicode' +import { Utils } from './Utils.js' +import { Unicode } from './Unicode.js' /** * MachineInput abstracts the input text supplied to the matching engine. @@ -40,7 +40,7 @@ class MachineUTF16Input extends MachineInputBase { this.end = end } - hasString(prefilter: any, pos: number): boolean { + override hasString(prefilter: any, pos: number): boolean { const idx = this.charSequence.indexOf(prefilter.str, this.start + pos) return idx !== -1 && idx <= this.end - prefilter.str.length } @@ -86,7 +86,7 @@ class MachineUTF16Input extends MachineInputBase { return Utils.emptyOpContext(r1, r2) } - prefixLength(re2: any): number { + override prefixLength(re2: any): number { return re2.prefix.length } } diff --git a/packages/cel/src/re2/Parser.ts b/packages/cel/src/re2/Parser.ts index 3eef00a..fb6c0ba 100644 --- a/packages/cel/src/re2/Parser.ts +++ b/packages/cel/src/re2/Parser.ts @@ -1,12 +1,12 @@ -import { RE2Flags } from './RE2Flags' -import { Unicode } from './Unicode' -import { UnicodeTables } from './UnicodeTables' -import { UnicodeRangeTable } from './UnicodeRangeTable' -import { getPerlGroups, getPosixGroups } from './CharGroup' -import { Utils } from './Utils' -import { CharClass } from './CharClass' -import { RE2JSSyntaxException } from './exceptions' -import { Regexp } from './Regexp' +import { RE2Flags } from './RE2Flags.js' +import { Unicode } from './Unicode.js' +import { UnicodeTables } from './UnicodeTables.js' +import { UnicodeRangeTable } from './UnicodeRangeTable.js' +import { getPerlGroups, getPosixGroups } from './CharGroup.js' +import { Utils } from './Utils.js' +import { CharClass } from './CharClass.js' +import { RE2JSSyntaxException } from './exceptions.js' +import { Regexp } from './Regexp.js' // StringIterator: a stream of runes with an opaque cursor, permitting // rewinding. The units of the cursor are not specified beyond the @@ -417,13 +417,11 @@ class Parser { case 0x34: case 0x35: case 0x36: + case 0x30: case 0x37: { - if (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37) { + if (c !== 0x30 && (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37)) { break } - } - // eslint-disable-next-line no-fallthrough - case 0x30: { let r = c - 0x30 for (let i = 1; i < 3; i++) { if (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37) { diff --git a/packages/cel/src/re2/Prefilter.ts b/packages/cel/src/re2/Prefilter.ts index 817df22..085c8b7 100644 --- a/packages/cel/src/re2/Prefilter.ts +++ b/packages/cel/src/re2/Prefilter.ts @@ -1,6 +1,6 @@ -import { Regexp } from './Regexp' +import { Regexp } from './Regexp.js' -import { RE2Flags } from './RE2Flags' +import { RE2Flags } from './RE2Flags.js' class Prefilter { type: number diff --git a/packages/cel/src/re2/Prog.ts b/packages/cel/src/re2/Prog.ts index dab187e..8923354 100644 --- a/packages/cel/src/re2/Prog.ts +++ b/packages/cel/src/re2/Prog.ts @@ -1,5 +1,5 @@ -import { RE2Flags } from './RE2Flags' -import { Inst } from './Inst' +import { RE2Flags } from './RE2Flags.js' +import { Inst } from './Inst.js' /** * A list of instruction pointers waiting to be patched. diff --git a/packages/cel/src/re2/RE2.ts b/packages/cel/src/re2/RE2.ts index 1357bc2..54da490 100644 --- a/packages/cel/src/re2/RE2.ts +++ b/packages/cel/src/re2/RE2.ts @@ -1,12 +1,12 @@ -import { RE2Flags } from './RE2Flags' -import { MachineInput } from './MachineInput' -import { DFA } from './DFA' -import { Inst } from './Inst' -import { PrefilterTree, Prefilter } from './Prefilter' -import { Compiler } from './Compiler' -import { Simplify } from './Simplify' -import { Parser } from './Parser' -import { Utils } from './Utils' +import { RE2Flags } from './RE2Flags.js' +import { MachineInput } from './MachineInput.js' +import { DFA } from './DFA.js' +import { Inst } from './Inst.js' +import { PrefilterTree, Prefilter } from './Prefilter.js' +import { Compiler } from './Compiler.js' +import { Simplify } from './Simplify.js' +import { Parser } from './Parser.js' +import { Utils } from './Utils.js' class RE2 { expr: string diff --git a/packages/cel/src/re2/Simplify.ts b/packages/cel/src/re2/Simplify.ts index f42057e..8aa7749 100644 --- a/packages/cel/src/re2/Simplify.ts +++ b/packages/cel/src/re2/Simplify.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from './RE2Flags' -import { Regexp } from './Regexp' -import { Unicode } from './Unicode' +import { RE2Flags } from './RE2Flags.js' +import { Regexp } from './Regexp.js' +import { Unicode } from './Unicode.js' class Simplify { // Simplify returns a regexp equivalent to re but without counted diff --git a/packages/cel/src/re2/Unicode.ts b/packages/cel/src/re2/Unicode.ts index 17d4786..e4ace64 100644 --- a/packages/cel/src/re2/Unicode.ts +++ b/packages/cel/src/re2/Unicode.ts @@ -1,5 +1,5 @@ -import { UnicodeRangeTable } from './UnicodeRangeTable' -import { UnicodeTables } from './UnicodeTables' +import { UnicodeRangeTable } from './UnicodeRangeTable.js' +import { UnicodeTables } from './UnicodeTables.js' /** * Utilities for dealing with Unicode better than JS does. */ diff --git a/packages/cel/src/re2/UnicodeTables.ts b/packages/cel/src/re2/UnicodeTables.ts index fed99b3..50abc14 100644 --- a/packages/cel/src/re2/UnicodeTables.ts +++ b/packages/cel/src/re2/UnicodeTables.ts @@ -1,7 +1,7 @@ // GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT. // yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts -import { UnicodeRangeTable } from './UnicodeRangeTable' +import { UnicodeRangeTable } from './UnicodeRangeTable.js' let _B64_MAP: Uint8Array | null = null const getB64Map = (): Uint8Array => { diff --git a/packages/cel/src/re2/Utils.ts b/packages/cel/src/re2/Utils.ts index ee25a30..5a6682c 100644 --- a/packages/cel/src/re2/Utils.ts +++ b/packages/cel/src/re2/Utils.ts @@ -1,4 +1,4 @@ -import { Unicode } from './Unicode' +import { Unicode } from './Unicode.js' /** * Various constants and helper utilities. */ diff --git a/packages/cel/src/re2/__utils__/parser.ts b/packages/cel/src/re2/__utils__/parser.ts index 9921fce..468cbef 100644 --- a/packages/cel/src/re2/__utils__/parser.ts +++ b/packages/cel/src/re2/__utils__/parser.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from '../RE2Flags' -import { Regexp } from '../Regexp' -import { Unicode } from '../Unicode' +import { RE2Flags } from '../RE2Flags.js' +import { Regexp } from '../Regexp.js' +import { Unicode } from '../Unicode.js' const OP_NAMES = new Map([ [Regexp.Op.NO_MATCH, 'no'], diff --git a/packages/cel/tsconfig.json b/packages/cel/tsconfig.json index b02b721..5dcff4f 100644 --- a/packages/cel/tsconfig.json +++ b/packages/cel/tsconfig.json @@ -1,5 +1,10 @@ { "files": ["src/index.ts", "src/ext/index.ts"], "extends": "../../tsconfig.base.json", - "include": ["src/**/*.test.ts"] + "include": ["src/**/*.test.ts"], + "exclude": [ + "src/re2/__tests__", + "src/re2/__fixtures__", + "src/re2/__utils__" + ] } From 9a4a33246d2d704f65cbc20d07db2cb9e886b653 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Fri, 17 Apr 2026 17:27:24 -0400 Subject: [PATCH 03/13] move re2 to its own package. add LICENCE and initial README.md --- package-lock.json | 44 +- package.json | 10 +- packages/cel-spec/src/testdata/conformance.ts | 31639 +++++++++++++++- packages/cel/package-lock.json | 270 - packages/cel/package.json | 5 +- packages/cel/src/std/logic.ts | 2 +- packages/cel/tsconfig.json | 5 - packages/re2/.npmignore | 10 + packages/re2/LICENSE | 21 + packages/re2/README.md | 30 + packages/re2/biome.json | 14 + packages/re2/package.json | 48 + .../re2/scripts}/codepointRange.js | 0 .../re2/scripts}/genUnicodeTable.js | 0 .../re2/scripts}/make_perl_groups.pl | 0 .../{cel/src/re2 => re2/src}/CharClass.ts | 0 .../{cel/src/re2 => re2/src}/CharGroup.ts | 0 .../{cel/src/re2 => re2/src}/Codepoint.ts | 0 packages/{cel/src/re2 => re2/src}/Compiler.ts | 0 packages/{cel/src/re2 => re2/src}/DFA.ts | 0 packages/{cel/src/re2 => re2/src}/Inst.ts | 0 .../{cel/src/re2 => re2/src}/MachineInput.ts | 0 packages/{cel/src/re2 => re2/src}/Parser.ts | 0 .../{cel/src/re2 => re2/src}/Prefilter.ts | 0 packages/{cel/src/re2 => re2/src}/Prog.ts | 0 packages/{cel/src/re2 => re2/src}/RE2.ts | 0 packages/{cel/src/re2 => re2/src}/RE2Flags.ts | 0 packages/{cel/src/re2 => re2/src}/Regexp.ts | 0 packages/{cel/src/re2 => re2/src}/Simplify.ts | 0 packages/{cel/src/re2 => re2/src}/Unicode.ts | 0 .../src/re2 => re2/src}/UnicodeRangeTable.ts | 0 .../{cel/src/re2 => re2/src}/UnicodeTables.ts | 0 packages/{cel/src/re2 => re2/src}/Utils.ts | 0 .../re2 => re2/src}/__fixtures__/basic.dat | 0 .../src/re2 => re2/src}/__fixtures__/find.ts | 0 .../src}/__fixtures__/nullsubexpr.dat | 0 .../src}/__fixtures__/re2-exhaustive.txt.gz | Bin .../src}/__fixtures__/re2-search.txt | 0 .../src}/__fixtures__/repetition.dat | 0 .../re2 => re2/src}/__tests__/BugHunt.test.ts | 0 .../src}/__tests__/CharClass.test.ts | 0 .../src}/__tests__/Codepoint.test.ts | 0 .../src/re2 => re2/src}/__tests__/DFA.test.ts | 0 .../re2 => re2/src}/__tests__/Exec.test.ts | 0 .../re2 => re2/src}/__tests__/Inst.test.ts | 0 .../re2 => re2/src}/__tests__/Parser.test.ts | 0 .../src}/__tests__/Prefilter.test.ts | 0 .../src}/__tests__/RE2Compile.test.ts | 0 .../src}/__tests__/RE2ExecuteEngine.test.ts | 0 .../src}/__tests__/RE2Match.test.ts | 0 .../src}/__tests__/RE2QuoteMeta.test.ts | 0 .../src}/__tests__/StressBoundary.test.ts | 0 .../__tests__/StressErrorRecovery.test.ts | 0 .../src}/__tests__/StressFlags.test.ts | 0 .../src}/__tests__/StressUnicode.test.ts | 0 .../re2 => re2/src}/__tests__/Unicode.test.ts | 0 .../src}/__tests__/UnicodeConformance.test.ts | 0 .../src}/__tests__/edge-cases.test.ts | 0 .../re2 => re2/src}/__tests__/index.test.ts | 0 .../src}/__tests__/stability.test.ts | 0 .../src/re2 => re2/src}/__utils__/chars.ts | 0 .../src/re2 => re2/src}/__utils__/parser.ts | 0 .../src/re2 => re2/src}/__utils__/unicode.ts | 0 .../{cel/src/re2 => re2/src}/exceptions.ts | 0 packages/{cel/src/re2 => re2/src}/index.ts | 0 packages/re2/tsconfig.json | 10 + scripts/release.js | 1 + 67 files changed, 31826 insertions(+), 283 deletions(-) delete mode 100644 packages/cel/package-lock.json create mode 100644 packages/re2/.npmignore create mode 100644 packages/re2/LICENSE create mode 100644 packages/re2/README.md create mode 100644 packages/re2/biome.json create mode 100644 packages/re2/package.json rename {scripts => packages/re2/scripts}/codepointRange.js (100%) rename {scripts => packages/re2/scripts}/genUnicodeTable.js (100%) rename {scripts => packages/re2/scripts}/make_perl_groups.pl (100%) rename packages/{cel/src/re2 => re2/src}/CharClass.ts (100%) rename packages/{cel/src/re2 => re2/src}/CharGroup.ts (100%) rename packages/{cel/src/re2 => re2/src}/Codepoint.ts (100%) rename packages/{cel/src/re2 => re2/src}/Compiler.ts (100%) rename packages/{cel/src/re2 => re2/src}/DFA.ts (100%) rename packages/{cel/src/re2 => re2/src}/Inst.ts (100%) rename packages/{cel/src/re2 => re2/src}/MachineInput.ts (100%) rename packages/{cel/src/re2 => re2/src}/Parser.ts (100%) rename packages/{cel/src/re2 => re2/src}/Prefilter.ts (100%) rename packages/{cel/src/re2 => re2/src}/Prog.ts (100%) rename packages/{cel/src/re2 => re2/src}/RE2.ts (100%) rename packages/{cel/src/re2 => re2/src}/RE2Flags.ts (100%) rename packages/{cel/src/re2 => re2/src}/Regexp.ts (100%) rename packages/{cel/src/re2 => re2/src}/Simplify.ts (100%) rename packages/{cel/src/re2 => re2/src}/Unicode.ts (100%) rename packages/{cel/src/re2 => re2/src}/UnicodeRangeTable.ts (100%) rename packages/{cel/src/re2 => re2/src}/UnicodeTables.ts (100%) rename packages/{cel/src/re2 => re2/src}/Utils.ts (100%) rename packages/{cel/src/re2 => re2/src}/__fixtures__/basic.dat (100%) rename packages/{cel/src/re2 => re2/src}/__fixtures__/find.ts (100%) rename packages/{cel/src/re2 => re2/src}/__fixtures__/nullsubexpr.dat (100%) rename packages/{cel/src/re2 => re2/src}/__fixtures__/re2-exhaustive.txt.gz (100%) rename packages/{cel/src/re2 => re2/src}/__fixtures__/re2-search.txt (100%) rename packages/{cel/src/re2 => re2/src}/__fixtures__/repetition.dat (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/BugHunt.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/CharClass.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/Codepoint.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/DFA.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/Exec.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/Inst.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/Parser.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/Prefilter.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/RE2Compile.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/RE2ExecuteEngine.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/RE2Match.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/RE2QuoteMeta.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/StressBoundary.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/StressErrorRecovery.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/StressFlags.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/StressUnicode.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/Unicode.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/UnicodeConformance.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/edge-cases.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/index.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__tests__/stability.test.ts (100%) rename packages/{cel/src/re2 => re2/src}/__utils__/chars.ts (100%) rename packages/{cel/src/re2 => re2/src}/__utils__/parser.ts (100%) rename packages/{cel/src/re2 => re2/src}/__utils__/unicode.ts (100%) rename packages/{cel/src/re2 => re2/src}/exceptions.ts (100%) rename packages/{cel/src/re2 => re2/src}/index.ts (100%) create mode 100644 packages/re2/tsconfig.json diff --git a/package-lock.json b/package-lock.json index 2ee8657..5641b7c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -7,8 +7,12 @@ "workspaces": [ "packages/cel-spec", "packages/cel", - "packages/example" + "packages/example", + "packages/re2" ], + "dependencies": { + "@bufbuild/re2": "^0.1.0" + }, "devDependencies": { "@arethetypeswrong/cli": "^0.18.2", "@biomejs/biome": "^1.9.4", @@ -476,6 +480,10 @@ "node": ">=14.17" } }, + "node_modules/@bufbuild/re2": { + "resolved": "packages/re2", + "link": true + }, "node_modules/@colors/colors": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz", @@ -1036,6 +1044,13 @@ "typescript": "*" } }, + "node_modules/@unicode/unicode-16.0.0": { + "version": "1.6.16", + "resolved": "https://registry.npmjs.org/@unicode/unicode-16.0.0/-/unicode-16.0.0-1.6.16.tgz", + "integrity": "sha512-R2Vxi0XEsCMD9WOQT85O2npa7g+i4RsJ8Xtn+/KODLqa5wH5zCTn5an6JILJhMSfFGD3t3amES2XnvUHnKjMZQ==", + "dev": true, + "license": "MIT" + }, "node_modules/ansi-escapes": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.2.0.tgz", @@ -1958,6 +1973,16 @@ "node": ">=4" } }, + "node_modules/unicode-property-value-aliases": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/unicode-property-value-aliases/-/unicode-property-value-aliases-3.9.0.tgz", + "integrity": "sha512-UFsQgFziRAXuFS9hN48PnwujNFwsuRWHj+bd840X7aYC1xa0MHlKsaxzapp5lM4C4HuAPko5cFiTUydeQ428Bg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "node_modules/validate-npm-package-name": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.1.tgz", @@ -2030,12 +2055,15 @@ "version": "0.4.0", "license": "Apache-2.0", "dependencies": { - "@bufbuild/cel-spec": "0.4.0" + "@bufbuild/cel-spec": "0.4.0", + "@bufbuild/re2": "*" }, "devDependencies": { + "@unicode/unicode-16.0.0": "^1.6.16", "expect-type": "^1.3.0", "peggy": "^5.0.6", - "peggy-ts": "github:hudlow/peggy-ts#v0.0.9" + "peggy-ts": "github:hudlow/peggy-ts#v0.0.9", + "unicode-property-value-aliases": "^3.9.0" }, "peerDependencies": { "@bufbuild/protobuf": "^2.6.2" @@ -2061,6 +2089,16 @@ "@bufbuild/cel-spec": "^0.4.0", "@bufbuild/protobuf": "^2.6.2" } + }, + "packages/re2": { + "name": "@bufbuild/re2", + "version": "0.1.0", + "license": "MIT", + "devDependencies": { + "@unicode/unicode-16.0.0": "^1.6.16", + "expect-type": "^1.3.0", + "unicode-property-value-aliases": "^3.9.0" + } } } } diff --git a/package.json b/package.json index 1ee9136..cf3821f 100644 --- a/package.json +++ b/package.json @@ -10,7 +10,12 @@ "license-header": "license-header --ignore 'packages/**'", "lint": "biome lint --error-on-warnings" }, - "workspaces": ["packages/cel-spec", "packages/cel", "packages/example"], + "workspaces": [ + "packages/cel-spec", + "packages/cel", + "packages/example", + "packages/re2" + ], "type": "module", "packageManager": "npm@10.9.0", "licenseHeader": { @@ -28,5 +33,8 @@ "tsx": "^4.21.0", "turbo": "^2.8.1", "typescript": "^5.9.3" + }, + "dependencies": { + "@bufbuild/re2": "^0.1.0" } } diff --git a/packages/cel-spec/src/testdata/conformance.ts b/packages/cel-spec/src/testdata/conformance.ts index 8ffbef0..9c9703d 100644 --- a/packages/cel-spec/src/testdata/conformance.ts +++ b/packages/cel-spec/src/testdata/conformance.ts @@ -1,2 +1,31639 @@ +// Copyright 2024-2026 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + // Generated from cel-go ../src/testdata/json -import type { SerializedIncrementalTestSuite } from './tests.js';export const tests: SerializedIncrementalTestSuite = {"name":"conformance","suites":[{"name":"basic","suites":[{"name":"self_eval_zeroish","tests":[{"original":{"name":"self_eval_int_zero","expr":"0","value":{"int64Value":"0"}},"ast":"0^#*expr.Constant_Int64Value#","checkedAst":"0~int","type":"int"},{"original":{"name":"self_eval_uint_zero","expr":"0u","value":{"uint64Value":"0"}},"ast":"0u^#*expr.Constant_Uint64Value#","checkedAst":"0u~uint","type":"uint"},{"original":{"name":"self_eval_uint_alias_zero","expr":"0U","value":{"uint64Value":"0"}},"ast":"0u^#*expr.Constant_Uint64Value#","checkedAst":"0u~uint","type":"uint"},{"original":{"name":"self_eval_float_zero","expr":"0.0","value":{"doubleValue":0}},"ast":"0^#*expr.Constant_DoubleValue#","checkedAst":"0~double","type":"double"},{"original":{"name":"self_eval_float_zerowithexp","expr":"0e+0","value":{"doubleValue":0}},"ast":"0^#*expr.Constant_DoubleValue#","checkedAst":"0~double","type":"double"},{"original":{"name":"self_eval_string_empty","expr":"''","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_string_empty_quotes","expr":"\"\"","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_string_raw_prefix","expr":"r\"\"","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_bytes_empty","expr":"b\"\"","value":{"bytesValue":""}},"ast":"b\"\"^#*expr.Constant_BytesValue#","checkedAst":"b\"\"~bytes","type":"bytes"},{"original":{"name":"self_eval_bool_false","expr":"false","value":{"boolValue":false}},"ast":"false^#*expr.Constant_BoolValue#","checkedAst":"false~bool","type":"bool"},{"original":{"name":"self_eval_null","expr":"null","value":{"nullValue":null}},"ast":"null^#*expr.Constant_NullValue#","checkedAst":"null~null","type":"null"},{"original":{"name":"self_eval_empty_list","expr":"[]","value":{"listValue":{}}},"ast":"[]^#*expr.Expr_ListExpr#","checkedAst":"[]~list(dyn)","type":"list(dyn)"},{"original":{"name":"self_eval_empty_map","expr":"{}","value":{"mapValue":{}}},"ast":"{}^#*expr.Expr_StructExpr#","checkedAst":"{}~map(dyn, dyn)","type":"map(dyn, dyn)"},{"original":{"name":"self_eval_string_raw_prefix_triple_double","expr":"r\"\"\"\"\"\"","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"},{"original":{"name":"self_eval_string_raw_prefix_triple_single","expr":"r''''''","value":{"stringValue":""}},"ast":"\"\"^#*expr.Constant_StringValue#","checkedAst":"\"\"~string","type":"string"}]},{"name":"self_eval_nonzeroish","tests":[{"original":{"name":"self_eval_int_nonzero","expr":"42","value":{"int64Value":"42"}},"ast":"42^#*expr.Constant_Int64Value#","checkedAst":"42~int","type":"int"},{"original":{"name":"self_eval_uint_nonzero","expr":"123456789u","value":{"uint64Value":"123456789"}},"ast":"123456789u^#*expr.Constant_Uint64Value#","checkedAst":"123456789u~uint","type":"uint"},{"original":{"name":"self_eval_uint_alias_nonzero","expr":"123456789U","value":{"uint64Value":"123456789"}},"ast":"123456789u^#*expr.Constant_Uint64Value#","checkedAst":"123456789u~uint","type":"uint"},{"original":{"name":"self_eval_int_negative_min","expr":"-9223372036854775808","value":{"int64Value":"-9223372036854775808"}},"ast":"-9223372036854775808^#*expr.Constant_Int64Value#","checkedAst":"-9223372036854775808~int","type":"int"},{"original":{"name":"self_eval_float_negative_exp","expr":"-2.3e+1","value":{"doubleValue":-23}},"ast":"-23^#*expr.Constant_DoubleValue#","checkedAst":"-23~double","type":"double"},{"original":{"name":"self_eval_string_excl","expr":"\"!\"","value":{"stringValue":"!"}},"ast":"\"!\"^#*expr.Constant_StringValue#","checkedAst":"\"!\"~string","type":"string"},{"original":{"name":"self_eval_string_escape","expr":"'\\''","value":{"stringValue":"'"}},"ast":"\"'\"^#*expr.Constant_StringValue#","checkedAst":"\"'\"~string","type":"string"},{"original":{"name":"self_eval_bytes_escape","expr":"b'ÿ'","value":{"bytesValue":"w78="}},"ast":"b\"ÿ\"^#*expr.Constant_BytesValue#","checkedAst":"b\"ÿ\"~bytes","type":"bytes"},{"original":{"name":"self_eval_bytes_invalid_utf8","expr":"b'\\000\\xff'","value":{"bytesValue":"AP8="}},"ast":"b\"\\x00\\xff\"^#*expr.Constant_BytesValue#","checkedAst":"b\"\\x00\\xff\"~bytes","type":"bytes"},{"original":{"name":"self_eval_list_singleitem","expr":"[-1]","value":{"listValue":{"values":[{"int64Value":"-1"}]}}},"ast":"[\n -1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n -1~int\n]~list(int)","type":"list(int)"},{"original":{"name":"self_eval_map_singleitem","expr":"{\"k\":\"v\"}","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}}]}}},"ast":"{\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"{\n \"k\"~string:\"v\"~string\n}~map(string, string)","type":"map(string, string)"},{"original":{"name":"self_eval_bool_true","expr":"true","value":{"boolValue":true}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"self_eval_int_hex","expr":"0x55555555","value":{"int64Value":"1431655765"}},"ast":"1431655765^#*expr.Constant_Int64Value#","checkedAst":"1431655765~int","type":"int"},{"original":{"name":"self_eval_int_hex_negative","expr":"-0x55555555","value":{"int64Value":"-1431655765"}},"ast":"-1431655765^#*expr.Constant_Int64Value#","checkedAst":"-1431655765~int","type":"int"},{"original":{"name":"self_eval_uint_hex","expr":"0x55555555u","value":{"uint64Value":"1431655765"}},"ast":"1431655765u^#*expr.Constant_Uint64Value#","checkedAst":"1431655765u~uint","type":"uint"},{"original":{"name":"self_eval_uint_alias_hex","expr":"0x55555555U","value":{"uint64Value":"1431655765"}},"ast":"1431655765u^#*expr.Constant_Uint64Value#","checkedAst":"1431655765u~uint","type":"uint"},{"original":{"name":"self_eval_unicode_escape_four","expr":"\"\\u270c\"","value":{"stringValue":"✌"}},"ast":"\"✌\"^#*expr.Constant_StringValue#","checkedAst":"\"✌\"~string","type":"string"},{"original":{"name":"self_eval_unicode_escape_eight","expr":"\"\\U0001f431\"","value":{"stringValue":"🐱"}},"ast":"\"🐱\"^#*expr.Constant_StringValue#","checkedAst":"\"🐱\"~string","type":"string"},{"original":{"name":"self_eval_ascii_escape_seq","expr":"\"\\a\\b\\f\\n\\r\\t\\v\\\"\\'\\\\\"","value":{"stringValue":"\u0007\b\f\n\r\t\u000b\"'\\"}},"ast":"\"\\a\\b\\f\\n\\r\\t\\v\\\"'\\\\\"^#*expr.Constant_StringValue#","checkedAst":"\"\\a\\b\\f\\n\\r\\t\\v\\\"'\\\\\"~string","type":"string"}]},{"name":"variables","tests":[{"original":{"name":"self_eval_bound_lookup","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"123"}}},"value":{"int64Value":"123"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~int^x","type":"int"},{"original":{"name":"self_eval_unbound_lookup","description":"An unbound variable should be marked as an error during execution. See google/cel-go#154","expr":"x","disableCheck":true,"evalError":{"errors":[{"message":"undeclared reference to 'x' (in container '')"}]}},"ast":"x^#*expr.Expr_IdentExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x\n | ^"},{"original":{"name":"unbound_is_runtime_error","description":"Make sure we can short-circuit around an unbound variable.","expr":"x || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n x^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x || true\n | ^"}]},{"name":"functions","tests":[{"original":{"name":"binop","expr":"1 + 1","value":{"int64Value":"2"}},"ast":"_+_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 1~int,\n 1~int\n)~int^add_int64","type":"int"},{"original":{"name":"unbound","expr":"f_unknown(17)","disableCheck":true,"evalError":{"errors":[{"message":"unbound function"}]}},"ast":"f_unknown(\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17)\n | .........^"},{"original":{"name":"unbound_is_runtime_error","expr":"f_unknown(17) || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n f_unknown(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17) || true\n | .........^"}]},{"name":"reserved_const","tests":[{"original":{"name":"false","expr":"false","typeEnv":[{"name":"false","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"false":{"value":{"boolValue":true}}},"value":{"boolValue":false}},"ast":"false^#*expr.Constant_BoolValue#","checkedAst":"false~bool","type":"bool"},{"original":{"name":"true","expr":"true","typeEnv":[{"name":"true","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"true":{"value":{"boolValue":false}}},"value":{"boolValue":true}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"null","expr":"null","typeEnv":[{"name":"null","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"null":{"value":{"boolValue":true}}},"value":{"nullValue":null}},"ast":"null^#*expr.Constant_NullValue#","checkedAst":"null~null","type":"null"}]}]},{"name":"bindings_ext","suites":[{"name":"bind","tests":[{"original":{"name":"boolean_literal","expr":"cel.bind(t, true, t)","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n t^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n t^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t~bool^t,\n // Result\n t~bool^t)~bool","type":"bool"},{"original":{"name":"string_concat","expr":"cel.bind(msg, \"hello\", msg + msg + msg)","value":{"stringValue":"hellohellohello"}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n msg^#*expr.Expr_IdentExpr#,\n \"hello\"^#*expr.Constant_StringValue#,\n _+_(\n _+_(\n msg^#*expr.Expr_IdentExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n msg,\n // Init\n \"hello\"~string,\n // LoopCondition\n false~bool,\n // LoopStep\n msg~string^msg,\n // Result\n _+_(\n _+_(\n msg~string^msg,\n msg~string^msg\n )~string^add_string,\n msg~string^msg\n )~string^add_string)~string","type":"string"},{"original":{"name":"bind_nested","expr":"cel.bind(t1, true, cel.bind(t2, true, t1 \u0026\u0026 t2))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n t1^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.bind(\n t2^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n _\u0026\u0026_(\n t1^#*expr.Expr_IdentExpr#,\n t2^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t1,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t1~bool^t1,\n // Result\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t2,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t2~bool^t2,\n // Result\n _\u0026\u0026_(\n t1~bool^t1,\n t2~bool^t2\n )~bool^logical_and)~bool)~bool","type":"bool"},{"original":{"name":"macro_exists","expr":"cel.bind(valid_elems, [1, 2, 3], [3, 4, 5].exists(e, e in valid_elems))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool)~bool","type":"bool"},{"original":{"name":"macro_not_exists","expr":"cel.bind(valid_elems, [1, 2, 3], ![4, 5].exists(e, e in valid_elems))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_not)~bool","type":"bool"}]}]},{"name":"block_ext","suites":[{"name":"basic","tests":[{"original":{"name":"int_add","expr":"cel.block([1, cel.index(0) + 1, cel.index(1) + 1, cel.index(2) + 1], cel.index(3))","value":{"int64Value":"4"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n 1^#*expr.Constant_Int64Value#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n 1~int,\n _+_(\n @index0~dyn^@index0,\n 1~int\n )~int^add_int64,\n _+_(\n @index1~dyn^@index1,\n 1~int\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(int),\n @index3~dyn^@index3\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_1","expr":"cel.block([[1, 2], size(cel.index(0)), cel.index(1) + cel.index(1), cel.index(2) + 1], cel.index(3))","value":{"int64Value":"5"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_2","expr":"cel.block([[1, 2], size(cel.index(0)), 2 + cel.index(1), cel.index(2) + cel.index(1), cel.index(3) + 1], cel.index(4))","value":{"int64Value":"7"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 2~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index3~dyn^@index3,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_3","expr":"cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), cel.index(1) + cel.index(1), cel.index(4) + cel.index(3), cel.index(5) + cel.index(3)], cel.index(6))","value":{"int64Value":"6"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index5~dyn^@index5,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"size_4","expr":"cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), [1, 2, 3], size(cel.index(4)), 5 + cel.index(1), cel.index(6) + cel.index(1), cel.index(7) + cel.index(3), cel.index(8) + cel.index(3), cel.index(9) + cel.index(5), cel.index(10) + cel.index(5)], cel.index(11))","value":{"int64Value":"17"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n size(\n @index4~dyn^@index4\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 5~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index6~dyn^@index6,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index7~dyn^@index7,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index8~dyn^@index8,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index9~dyn^@index9,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index10~dyn^@index10,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"timestamp","expr":"cel.block([timestamp(1000000000), int(cel.index(0)), timestamp(cel.index(1)), cel.index(2).getFullYear(), timestamp(50), int(cel.index(4)), timestamp(cel.index(5)), timestamp(200), int(cel.index(7)), timestamp(cel.index(8)), cel.index(9).getFullYear(), timestamp(75), int(cel.index(11)), timestamp(cel.index(12)), cel.index(13).getFullYear(), cel.index(3) + cel.index(14), cel.index(6).getFullYear(), cel.index(15) + cel.index(16), cel.index(17) + cel.index(3), cel.index(6).getSeconds(), cel.index(18) + cel.index(19), cel.index(20) + cel.index(10), cel.index(21) + cel.index(10), cel.index(13).getMinutes(), cel.index(22) + cel.index(23), cel.index(24) + cel.index(3)], cel.index(25))","value":{"int64Value":"13934"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 200^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 14^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 16^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 18^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 19^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 21^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp,\n int(\n @index0~dyn^@index0\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index1~dyn^@index1\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index2~dyn^@index2.getFullYear()~int^timestamp_to_year,\n timestamp(\n 50~int\n )~timestamp^int64_to_timestamp,\n int(\n @index4~dyn^@index4\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index5~dyn^@index5\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n timestamp(\n 200~int\n )~timestamp^int64_to_timestamp,\n int(\n @index7~dyn^@index7\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index8~dyn^@index8\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index9~dyn^@index9.getFullYear()~int^timestamp_to_year,\n timestamp(\n 75~int\n )~timestamp^int64_to_timestamp,\n int(\n @index11~dyn^@index11\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index12~dyn^@index12\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index13~dyn^@index13.getFullYear()~int^timestamp_to_year,\n _+_(\n @index3~dyn^@index3,\n @index14~dyn^@index14\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getFullYear()~int^timestamp_to_year,\n _+_(\n @index15~dyn^@index15,\n @index16~dyn^@index16\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index17~dyn^@index17,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getSeconds()~int^duration_to_seconds|timestamp_to_seconds,\n _+_(\n @index18~dyn^@index18,\n @index19~dyn^@index19\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index20~dyn^@index20,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index21~dyn^@index21,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index13~dyn^@index13.getMinutes()~int^duration_to_minutes|timestamp_to_minutes,\n _+_(\n @index22~dyn^@index22,\n @index23~dyn^@index23\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index24~dyn^@index24,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index25~dyn^@index25\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"map_index","expr":"cel.block([{\"a\": 2}, cel.index(0)[\"a\"], cel.index(1) * cel.index(1), cel.index(1) + cel.index(2)], cel.index(3))","value":{"int64Value":"6"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"a\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"a\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"a\"~string:2~int\n }~map(string, int),\n _[_](\n @index0~dyn^@index0,\n \"a\"~string\n )~dyn^index_map|optional_map_index_value,\n _*_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^multiply_double|multiply_int64|multiply_uint64,\n _+_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"nested_map_construction","expr":"cel.block([{\"b\": 1}, {\"e\": cel.index(0)}], {\"a\": cel.index(0), \"c\": cel.index(0), \"d\": cel.index(1), \"e\": cel.index(1)})","value":{"mapValue":{"entries":[{"key":{"stringValue":"a"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}},{"key":{"stringValue":"c"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}},{"key":{"stringValue":"d"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"e"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}}]}}},{"key":{"stringValue":"e"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"e"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"b"},"value":{"int64Value":"1"}}]}}}]}}}]}}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"b\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"e\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n {\n \"a\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"c\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"d\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"e\"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"b\"~string:1~int\n }~map(string, int),\n {\n \"e\"~string:@index0~dyn^@index0\n }~map(string, dyn)\n ]~list(map(string, dyn)),\n {\n \"a\"~string:@index0~dyn^@index0,\n \"c\"~string:@index0~dyn^@index0,\n \"d\"~string:@index1~dyn^@index1,\n \"e\"~string:@index1~dyn^@index1\n }~map(string, dyn)\n)~map(string, dyn)^cel_block_list","type":"map(string, dyn)"},{"original":{"name":"nested_list_construction","expr":"cel.block([[1, 2, 3, 4], [1, 2], [cel.index(1), cel.index(0)]], [1, cel.index(0), 2, cel.index(0), 5, cel.index(0), 7, cel.index(2), cel.index(1)])","value":{"listValue":{"values":[{"int64Value":"1"},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"int64Value":"2"},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"int64Value":"5"},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"int64Value":"7"},{"listValue":{"values":[{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"}]}},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}}]}},{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"}]}}]}}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n [\n 1~int,\n 2~int\n ]~list(int),\n [\n @index1~dyn^@index1,\n @index0~dyn^@index0\n ]~list(dyn)\n ]~list(list(dyn)),\n [\n 1~int,\n @index0~dyn^@index0,\n 2~int,\n @index0~dyn^@index0,\n 5~int,\n @index0~dyn^@index0,\n 7~int,\n @index2~dyn^@index2,\n @index1~dyn^@index1\n ]~list(dyn)\n)~list(dyn)^cel_block_list","type":"list(dyn)"},{"original":{"name":"select","expr":"cel.block([msg.single_int64, cel.index(0) + cel.index(0)], cel.index(1))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"6"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index0~dyn^@index0,\n @index0~dyn^@index0\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index1~dyn^@index1\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"select_nested_1","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, cel.index(1).single_int32, cel.index(2) + cel.index(3), cel.index(4) + cel.index(2), msg.single_int64, cel.index(5) + cel.index(6), cel.index(1).oneof_type, cel.index(8).payload, cel.index(9).single_int64, cel.index(7) + cel.index(10)], cel.index(11))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"31"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int32~dyn,\n _+_(\n @index2~dyn^@index2,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index1~dyn^@index1.oneof_type~dyn,\n @index8~dyn^@index8.payload~dyn,\n @index9~dyn^@index9.single_int64~dyn,\n _+_(\n @index7~dyn^@index7,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"select_nested_2","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).oneof_type, cel.index(2).payload, cel.index(3).oneof_type, cel.index(4).payload, cel.index(5).oneof_type, cel.index(6).payload, cel.index(7).single_bool, true || cel.index(8), cel.index(4).child, cel.index(10).child, cel.index(11).payload, cel.index(12).single_bool], cel.index(9) || cel.index(13))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#,\n _||_(\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _||_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.oneof_type~dyn,\n @index2~dyn^@index2.payload~dyn,\n @index3~dyn^@index3.oneof_type~dyn,\n @index4~dyn^@index4.payload~dyn,\n @index5~dyn^@index5.oneof_type~dyn,\n @index6~dyn^@index6.payload~dyn,\n @index7~dyn^@index7.single_bool~dyn,\n _||_(\n true~bool,\n @index8~dyn^@index8\n )~bool^logical_or,\n @index4~dyn^@index4.child~dyn,\n @index10~dyn^@index10.child~dyn,\n @index11~dyn^@index11.payload~dyn,\n @index12~dyn^@index12.single_bool~dyn\n ]~list(dyn),\n _||_(\n @index9~dyn^@index9,\n @index13~dyn^@index13\n )~bool^logical_or\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"select_nested_message_map_index_1","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[1], cel.index(3) + cel.index(3), cel.index(4) + cel.index(3)], cel.index(5))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"15"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"select_nested_message_map_index_2","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[0], cel.index(2)[1], cel.index(3) + cel.index(4), cel.index(2)[2], cel.index(5) + cel.index(6)], cel.index(7))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"8"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 0~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _[_](\n @index2~dyn^@index2,\n 2~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index7~dyn^@index7\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"ternary","expr":"cel.block([msg.single_int64, cel.index(0) \u003e 0, cel.index(1) ? cel.index(0) : 0], cel.index(2))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"3"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _?_:_(\n @index1~dyn^@index1,\n @index0~dyn^@index0,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index2~dyn^@index2\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"nested_ternary","expr":"cel.block([msg.single_int64, msg.single_int32, cel.index(0) \u003e 0, cel.index(1) \u003e 0, cel.index(0) + cel.index(1), cel.index(3) ? cel.index(4) : 0, cel.index(2) ? cel.index(5) : 0], cel.index(6))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"8"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int32~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _\u003e_(\n @index1~dyn^@index1,\n 0~int\n )~bool^greater_int64,\n _+_(\n @index0~dyn^@index0,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _?_:_(\n @index3~dyn^@index3,\n @index4~dyn^@index4,\n 0~int\n )~dyn^conditional,\n _?_:_(\n @index2~dyn^@index2,\n @index5~dyn^@index5,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"multiple_macros_1","expr":"cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))","value":{"int64Value":"4"}},"error":"ERROR: multiple_macros_1:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_1:1:110: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .............................................................................................................^"},{"original":{"name":"multiple_macros_2","expr":"cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))","value":{"listValue":{"values":[{"boolValue":true},{"boolValue":true},{"boolValue":true},{"boolValue":true}]}}},"error":"ERROR: multiple_macros_2:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_2:1:106: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .........................................................................................................^"},{"original":{"name":"multiple_macros_3","expr":"cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))","value":{"boolValue":false}},"error":"ERROR: multiple_macros_3:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | .................................^\nERROR: multiple_macros_3:1:121: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ........................................................................................................................^\nERROR: multiple_macros_3:1:177: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ................................................................................................................................................................................^"},{"original":{"name":"nested_macros_1","expr":"cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))","value":{"listValue":{"values":[{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}},{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"3"},{"int64Value":"4"}]}}]}}},"error":"ERROR: nested_macros_1:1:52: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | ...................................................^\nERROR: nested_macros_1:1:88: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | .......................................................................................^"},{"original":{"name":"nested_macros_2","expr":"[1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))","value":{"listValue":{"values":[{"listValue":{"values":[{"int64Value":"1"}]}},{"listValue":{"values":[{"int64Value":"2"}]}}]}}},"error":"ERROR: nested_macros_2:1:23: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ......................^\nERROR: nested_macros_2:1:59: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ..........................................................^"},{"original":{"name":"adjacent_macros","expr":"cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))","value":{"boolValue":true}},"error":"ERROR: adjacent_macros:1:51: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ..................................................^\nERROR: adjacent_macros:1:87: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ......................................................................................^"},{"original":{"name":"macro_shadowed_variable_1","expr":"cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"5"}}},"value":{"boolValue":true}},"error":"ERROR: macro_shadowed_variable_1:1:90: argument must be a simple name\n | cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))\n | .........................................................................................^"},{"original":{"name":"macro_shadowed_variable_2","expr":"['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"5"}}},"value":{"listValue":{"values":[{"listValue":{"values":[{"listValue":{"values":[{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"}]}},{"listValue":{"values":[{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"},{"stringValue":"foofoo"}]}}]}},{"listValue":{"values":[{"listValue":{"values":[{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"}]}},{"listValue":{"values":[{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"},{"stringValue":"barbar"}]}}]}}]}}},"error":"ERROR: macro_shadowed_variable_2:1:31: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | ..............................^\nERROR: macro_shadowed_variable_2:1:134: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | .....................................................................................................................................^"},{"original":{"name":"inclusion_list","expr":"cel.block([[1, 2, 3], 1 in cel.index(0), 2 in cel.index(0), cel.index(1) \u0026\u0026 cel.index(2), [3, cel.index(0)], 3 in cel.index(4), cel.index(5) \u0026\u0026 cel.index(1)], cel.index(3) \u0026\u0026 cel.index(6))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n @in(\n 1~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n @in(\n 2~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and,\n [\n 3~int,\n @index0~dyn^@index0\n ]~list(dyn),\n @in(\n 3~int,\n @index4~dyn^@index4\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index1~dyn^@index1\n )~bool^logical_and\n ]~list(dyn),\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index6~dyn^@index6\n )~bool^logical_and\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"inclusion_map","expr":"cel.block([{true: false}, {\"a\": 1, 2: cel.index(0), 3: cel.index(0)}], 2 in cel.index(1))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n true^#*expr.Constant_BoolValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n true~bool:false~bool\n }~map(bool, bool),\n {\n \"a\"~string:1~int,\n 2~int:@index0~dyn^@index0,\n 3~int:@index0~dyn^@index0\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn)),\n @in(\n 2~int,\n @index1~dyn^@index1\n )~bool^in_list|in_map\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"presence_test","expr":"cel.block([{\"a\": true}, has(cel.index(0).a), cel.index(0)[\"a\"]], cel.index(1) \u0026\u0026 cel.index(2))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"a\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"a\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"a\"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool,\n _[_](\n @index0~dyn^@index0,\n \"a\"~string\n )~dyn^index_map|optional_map_index_value\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"presence_test_2","expr":"cel.block([{\"a\": true}, has(cel.index(0).a)], cel.index(1) \u0026\u0026 cel.index(1))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n \"a\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n {\n \"a\"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~bool^logical_and\n)~bool^cel_block_list","type":"bool"},{"original":{"name":"presence_test_with_ternary","expr":"cel.block([msg.oneof_type, has(cel.index(0).payload), cel.index(0).payload, cel.index(2).single_int64, cel.index(1) ? cel.index(3) : 0], cel.index(4))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"10"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~test-only~~bool,\n @index0~dyn^@index0.payload~dyn,\n @index2~dyn^@index2.single_int64~dyn,\n _?_:_(\n @index1~dyn^@index1,\n @index3~dyn^@index3,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"presence_test_with_ternary_2","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(0).payload), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"10"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index0~dyn^@index0.payload~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"presence_test_with_ternary_3","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(1).single_int64), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"int64Value":"10"}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"presence_test_with_ternary_nested","expr":"cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_string_string, has(msg.oneof_type), has(cel.index(0).payload), cel.index(3) \u0026\u0026 cel.index(4), has(cel.index(1).single_int64), cel.index(5) \u0026\u0026 cel.index(6), has(cel.index(1).map_string_string), has(cel.index(2).key), cel.index(8) \u0026\u0026 cel.index(9), cel.index(2).key, cel.index(11) == \"A\", cel.index(10) ? cel.index(12) : false], cel.index(7) ? cel.index(13) : false)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":5,"singleInt64":"3","oneofType":{"payload":{"singleInt32":8,"singleInt64":"10","mapInt32Int64":{"0":"1","1":"5","2":"2"},"mapStringString":{"key":"A"}}}}}}},"value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.oneof_type~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key^#*expr.Expr_SelectExpr#,\n _==_(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"A\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_string_string~dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~test-only~~bool,\n @index0~dyn^@index0.payload~test-only~~bool,\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~bool^logical_and,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~bool^logical_and,\n @index1~dyn^@index1.map_string_string~test-only~~bool,\n @index2~dyn^@index2.key~test-only~~bool,\n _\u0026\u0026_(\n @index8~dyn^@index8,\n @index9~dyn^@index9\n )~bool^logical_and,\n @index2~dyn^@index2.key~dyn,\n _==_(\n @index11~dyn^@index11,\n \"A\"~string\n )~bool^equals,\n _?_:_(\n @index10~dyn^@index10,\n @index12~dyn^@index12,\n false~bool\n )~dyn^conditional\n ]~list(dyn),\n _?_:_(\n @index7~dyn^@index7,\n @index13~dyn^@index13,\n false~bool\n )~dyn^conditional\n)~dyn^cel_block_list","type":"dyn"},{"original":{"name":"optional_list","expr":"cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))","typeEnv":[{"name":"opt_x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"opt_x":{"value":{"int64Value":"5"}}},"value":{"boolValue":true}},"error":"ERROR: optional_list:1:30: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | .............................^\nERROR: optional_list:1:45: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................^\nERROR: optional_list:1:77: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................................................^"},{"original":{"name":"optional_map","expr":"cel.block([optional.of(\"hello\"), {?\"hello\": cel.index(0)}, cel.index(1)[\"hello\"], cel.index(2) + cel.index(2)], cel.index(3) == \"hellohello\")","value":{"boolValue":true}},"error":"ERROR: optional_map:1:35: unsupported syntax '?'\n | cel.block([optional.of(\"hello\"), {?\"hello\": cel.index(0)}, cel.index(1)[\"hello\"], cel.index(2) + cel.index(2)], cel.index(3) == \"hellohello\")\n | ..................................^"},{"original":{"name":"optional_map_chained","expr":"cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))","value":{"stringValue":"test"}},"error":"ERROR: optional_map_chained:1:51: unsupported syntax '?'\n | cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | ..................................................^\nERROR: optional_map_chained:1:86: unsupported syntax '[?'\n | cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .....................................................................................^\nERROR: optional_map_chained:1:110: unsupported syntax '[?'\n | cel.block([{\"key\": \"test\"}, optional.of(\"test\"), {?\"key\": cel.index(1)}, cel.index(2)[?\"bogus\"], cel.index(0)[?\"bogus\"], cel.index(3).or(cel.index(4)), cel.index(0)[\"key\"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .............................................................................................................^"},{"original":{"name":"optional_message","expr":"cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))","container":"cel.expr.conformance.proto3","value":{"int64Value":"5"}},"error":"ERROR: optional_message:1:69: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | ....................................................................^\nERROR: optional_message:1:98: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | .................................................................................................^"},{"original":{"name":"call","expr":"cel.block([\"h\" + \"e\", cel.index(0) + \"l\", cel.index(1) + \"l\", cel.index(2) + \"o\", cel.index(3) + \" world\"], cel.index(4).matches(cel.index(3)))","value":{"boolValue":true}},"ast":"cel^#*expr.Expr_IdentExpr#.block(\n [\n _+_(\n \"h\"^#*expr.Constant_StringValue#,\n \"e\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"l\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"l\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"o\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \" world\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.matches(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"cel.@block(\n [\n _+_(\n \"h\"~string,\n \"e\"~string\n )~string^add_string,\n _+_(\n @index0~dyn^@index0,\n \"l\"~string\n )~string^add_string,\n _+_(\n @index1~dyn^@index1,\n \"l\"~string\n )~string^add_string,\n _+_(\n @index2~dyn^@index2,\n \"o\"~string\n )~string^add_string,\n _+_(\n @index3~dyn^@index3,\n \" world\"~string\n )~string^add_string\n ]~list(string),\n @index4~dyn^@index4.matches(\n @index3~dyn^@index3\n )~bool^matches_string\n)~bool^cel_block_list","type":"bool"}]}]},{"name":"comparisons","suites":[{"name":"eq_literal","tests":[{"original":{"name":"eq_int","expr":"1 == 1","value":{"boolValue":true}},"ast":"_==_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 1~int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int","expr":"-1 == 1","value":{"boolValue":false}},"ast":"_==_(\n -1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n -1~int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int_uint","expr":"dyn(1) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int_uint","expr":"dyn(2) == 1u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int_double","expr":"dyn(1) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int_double","expr":"dyn(2) == 1.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint","expr":"2u == 2u","value":{"boolValue":true}},"ast":"_==_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 2u~uint,\n 2u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint","expr":"1u == 2u","value":{"boolValue":false}},"ast":"_==_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 1u~uint,\n 2u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint_int","expr":"dyn(1u) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint_int","expr":"dyn(2u) == 1","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint_double","expr":"dyn(1u) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint_double","expr":"dyn(2u) == 1.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double","expr":"1.0 == 1.0e+0","value":{"boolValue":true}},"ast":"_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 1~double,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double","expr":"-1.0 == 1.0","value":{"boolValue":false}},"ast":"_==_(\n -1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n -1~double,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double_nan","expr":"0.0/0.0 == 0.0/0.0","value":{"boolValue":false}},"ast":"_==_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_int_double_nan","expr":"dyn(1) == 0.0/0.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_uint_double_nan","expr":"dyn(1u) == 0.0/0.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_int","expr":"dyn(1.0) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double_int","expr":"dyn(2.0) == 1","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_uint","expr":"dyn(1.0) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_double_uint","expr":"dyn(2.0) == 1u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string","expr":"'' == \"\"","value":{"boolValue":true}},"ast":"_==_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\"~string,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_string","expr":"'a' == 'b'","value":{"boolValue":false}},"ast":"_==_(\n \"a\"^#*expr.Constant_StringValue#,\n \"b\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"a\"~string,\n \"b\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_raw_string","expr":"'abc' == r'abc'","value":{"boolValue":true}},"ast":"_==_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"abc\"~string,\n \"abc\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_string_case","expr":"'abc' == 'ABC'","value":{"boolValue":false}},"ast":"_==_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"ABC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"abc\"~string,\n \"ABC\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_unicode","expr":"'ίσος' == 'ίσος'","value":{"boolValue":true}},"ast":"_==_(\n \"ίσος\"^#*expr.Constant_StringValue#,\n \"ίσος\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ίσος\"~string,\n \"ίσος\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_string_unicode_ascii","expr":"'a' == 'à'","value":{"boolValue":false}},"ast":"_==_(\n \"a\"^#*expr.Constant_StringValue#,\n \"à\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"a\"~string,\n \"à\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"no_string_normalization","description":"Should not normalize Unicode.","expr":"'Am\\u00E9lie' == 'Ame\\u0301lie'","value":{"boolValue":false}},"ast":"_==_(\n \"Amélie\"^#*expr.Constant_StringValue#,\n \"Amélie\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"Amélie\"~string,\n \"Amélie\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_null","expr":"null == null","value":{"boolValue":true}},"ast":"_==_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n null~null,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool","expr":"true == true","value":{"boolValue":true}},"ast":"_==_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n true~bool,\n true~bool\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_bool","expr":"false == true","value":{"boolValue":false}},"ast":"_==_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n false~bool,\n true~bool\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes","description":"Test bytes literal equality with encoding","expr":"b'ÿ' == b'\\303\\277'","value":{"boolValue":true}},"ast":"_==_(\n b\"ÿ\"^#*expr.Constant_BytesValue#,\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n b\"ÿ\"~bytes,\n b\"ÿ\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_bytes","expr":"b'abc' == b'abcd'","value":{"boolValue":false}},"ast":"_==_(\n b\"abc\"^#*expr.Constant_BytesValue#,\n b\"abcd\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n b\"abc\"~bytes,\n b\"abcd\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_empty","expr":"[] == []","value":{"boolValue":true}},"ast":"_==_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n []~list(dyn),\n []~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_null","expr":"[null] == [null]","value":{"boolValue":true}},"ast":"_==_(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n null~null\n ]~list(null),\n [\n null~null\n ]~list(null)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_null","expr":"['1', '2', null] == ['1', '2', '3']","value":{"boolValue":false}},"ast":"_==_(\n [\n \"1\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n \"1\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#,\n \"3\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"1\"~string,\n \"2\"~string,\n null~null\n ]~list(dyn),\n [\n \"1\"~string,\n \"2\"~string,\n \"3\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_numbers","expr":"[1, 2, 3] == [1, 2, 3]","value":{"boolValue":true}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_list_mixed_type_numbers","expr":"[1.0, 2.0, 3] == [1u, 2, 3u]","value":{"boolValue":true}},"ast":"_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~double,\n 2~double,\n 3~int\n ]~list(dyn),\n [\n 1u~uint,\n 2~int,\n 3u~uint\n ]~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_mixed_type_numbers","expr":"[1.0, 2.1] == [1u, 2]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2.1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~double,\n 2.1~double\n ]~list(double),\n [\n 1u~uint,\n 2~int\n ]~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_order","expr":"[1, 2, 3] == [1, 3, 2]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 3~int,\n 2~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_string_case","expr":"['case'] == ['cAse']","value":{"boolValue":false}},"ast":"_==_(\n [\n \"case\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n \"cAse\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"case\"~string\n ]~list(string),\n [\n \"cAse\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_length","expr":"['one'] == [2, 3]","disableCheck":true,"value":{"boolValue":false}},"ast":"_==_(\n [\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_==_' applied to '(list(string), list(int))'\n | ['one'] == [2, 3]\n | ........^"},{"original":{"name":"not_eq_list_false_vs_types","expr":"[1, 'dos', 3] == [1, 2, 4]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n \"dos\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n \"dos\"~string,\n 3~int\n ]~list(dyn),\n [\n 1~int,\n 2~int,\n 4~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_empty","expr":"{} == {}","value":{"boolValue":true}},"ast":"_==_(\n {}^#*expr.Expr_StructExpr#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {}~map(dyn, dyn),\n {}~map(dyn, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_null","expr":"{'k': null} == {'k': null}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:null~null\n }~map(string, null),\n {\n \"k\"~string:null~null\n }~map(string, null)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_null","expr":"{'k': 1, 'j': 2} == {'k': 1, 'j': null}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"j\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"j\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:1~int,\n \"j\"~string:2~int\n }~map(string, int),\n {\n \"k\"~string:1~int,\n \"j\"~string:null~null\n }~map(string, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_onekey","expr":"{'k':'v'} == {\"k\":\"v\"}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_double_value","expr":"{'k':1.0} == {'k':1e+0}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:1~double\n }~map(string, double),\n {\n \"k\"~string:1~double\n }~map(string, double)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_mixed_type_numbers","expr":"{1: 1.0, 2u: 3u} == {1u: 1, 2: 3.0}","value":{"boolValue":true}},"ast":"_==_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n 1~int:1~double,\n 2u~uint:3u~uint\n }~map(dyn, dyn),\n {\n 1u~uint:1~int,\n 2~int:3~double\n }~map(dyn, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_value","expr":"{'k':'v'} == {'k':'v1'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v1\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_extra_key","expr":"{'k':'v','k1':'v1'} == {'k':'v'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string,\n \"k1\"~string:\"v1\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_map_key_order","expr":"{'k1':'v1','k2':'v2'} == {'k2':'v2','k1':'v1'}","value":{"boolValue":true}},"ast":"_==_(\n {\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k2\"^#*expr.Constant_StringValue#:\"v2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k2\"^#*expr.Constant_StringValue#:\"v2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k1\"~string:\"v1\"~string,\n \"k2\"~string:\"v2\"~string\n }~map(string, string),\n {\n \"k2\"~string:\"v2\"~string,\n \"k1\"~string:\"v1\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_key_casing","expr":"{'key':'value'} == {'Key':'value'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"key\"^#*expr.Constant_StringValue#:\"value\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"Key\"^#*expr.Constant_StringValue#:\"value\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"key\"~string:\"value\"~string\n }~map(string, string),\n {\n \"Key\"~string:\"value\"~string\n }~map(string, string)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_false_vs_types","expr":"{'k1': 1, 'k2': 'dos', 'k3': 3} == {'k1': 1, 'k2': 2, 'k3': 4}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"k2\"^#*expr.Constant_StringValue#:\"dos\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k3\"^#*expr.Constant_StringValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"k2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"k3\"^#*expr.Constant_StringValue#:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k1\"~string:1~int,\n \"k2\"~string:\"dos\"~string,\n \"k3\"~string:3~int\n }~map(string, dyn),\n {\n \"k1\"~string:1~int,\n \"k2\"~string:2~int,\n \"k3\"~string:4~int\n }~map(string, int)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_mixed_types","expr":"1.0 == 1","disableCheck":true,"value":{"boolValue":true}},"ast":"_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(double, int)'\n | 1.0 == 1\n | ....^"},{"original":{"name":"eq_list_elem_mixed_types","expr":"[1] == [1.0]","disableCheck":true,"value":{"boolValue":true}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(list(int), list(double))'\n | [1] == [1.0]\n | ....^"},{"original":{"name":"eq_map_value_mixed_types","expr":"{'k':'v', 1:1} == {'k':'v', 1:'v1'}","value":{"boolValue":false}},"ast":"_==_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n \"k\"~string:\"v\"~string,\n 1~int:1~int\n }~map(dyn, dyn),\n {\n \"k\"~string:\"v\"~string,\n 1~int:\"v1\"~string\n }~map(dyn, string)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_json_null","expr":"dyn(google.protobuf.Value{}) == null","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n google.protobuf.Value{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n google.protobuf.Value{}~dyn^google.protobuf.Value\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_bool_null","expr":"dyn(false) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n false~bool\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_bytes_null","expr":"dyn(b'') == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_double_null","expr":"dyn(2.1) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 2.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 2.1~double\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_duration_null","expr":"dyn(duration('0s')) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n duration(\n \"0s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n duration(\n \"0s\"~string\n )~duration^string_to_duration\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_int_null","expr":"dyn(1) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_list_null","expr":"dyn([]) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_map_null","expr":"dyn({}) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n {}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n {}~map(dyn, dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_proto2_msg_null","expr":"dyn(TestAllTypes{}) == null","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_proto3_msg_null","expr":"dyn(TestAllTypes{}) == null","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_string_null","expr":"dyn('') == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n \"\"~string\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_timestamp_null","expr":"dyn(timestamp(0)) == null","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n timestamp(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n timestamp(\n 0~int\n )~timestamp^int64_to_timestamp\n )~dyn^to_dyn,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_list_elem_null","expr":"[1, 2, null] == [1, null, 3]","value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int,\n null~null\n ]~list(dyn),\n [\n 1~int,\n null~null,\n 3~int\n ]~list(dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_map_value_null","expr":"{1:'hello', 2:'world'} == {1:'goodbye', 2:null}","value":{"boolValue":false}},"ast":"_==_(\n {\n 1^#*expr.Constant_Int64Value#:\"hello\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:\"world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n {\n 1~int:\"hello\"~string,\n 2~int:\"world\"~string\n }~map(int, string),\n {\n 1~int:\"goodbye\"~string,\n 2~int:null~null\n }~map(int, dyn)\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_int_uint","expr":"dyn(1) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_int_double","expr":"dyn(1) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_uint_int","expr":"dyn(1u) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_uint_double","expr":"dyn(1u) == 1.0","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_double_int","expr":"dyn(1.0) == 1","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_dyn_double_uint","expr":"dyn(1.0) == 1u","value":{"boolValue":true}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_int_uint","expr":"dyn(1) == 2u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_int_double","expr":"dyn(1) == 2.0","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_uint_int","expr":"dyn(1u) == 2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_uint_double","expr":"dyn(1u) == 120","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 120^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 120~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_double_int","expr":"dyn(1.0) == 2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"not_eq_dyn_double_uint","expr":"dyn(1.0) == 2u","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals","type":"bool"}]},{"name":"eq_wrapper","tests":[{"original":{"name":"eq_bool","expr":"google.protobuf.BoolValue{value: true} == true","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue,\n true~bool\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool_empty","expr":"google.protobuf.BoolValue{} == false","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n false~bool\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool_not_null","expr":"google.protobuf.BoolValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_bool_proto2_null","expr":"TestAllTypes{}.single_bool_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bool_proto3_null","expr":"TestAllTypes{}.single_bool_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes","expr":"google.protobuf.BytesValue{value: b'set'} == b'set'","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BytesValue{\n value:b\"set\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n b\"set\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BytesValue{\n value:b\"set\"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue,\n b\"set\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes_empty","expr":"google.protobuf.BytesValue{} == b''","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n b\"\"~bytes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes_not_null","expr":"google.protobuf.BytesValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_bytes_proto2_null","expr":"TestAllTypes{}.single_bytes_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_bytes_proto3_null","expr":"TestAllTypes{}.single_bytes_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double","expr":"google.protobuf.DoubleValue{value: -1.175494e-40} == -1.175494e-40","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.175494e-40^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40~double\n }~wrapper(double)^google.protobuf.DoubleValue,\n -1.175494e-40~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_empty","expr":"google.protobuf.DoubleValue{} == 0.0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n 0~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_not_null","expr":"google.protobuf.DoubleValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_double_proto2_null","expr":"TestAllTypes{}.single_double_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_double_proto3_null","expr":"TestAllTypes{}.single_double_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float","expr":"google.protobuf.FloatValue{value: -1.5} == -1.5","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.FloatValue{\n value:-1.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:-1.5~double\n }~wrapper(double)^google.protobuf.FloatValue,\n -1.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float_empty","expr":"google.protobuf.FloatValue{} == 0.0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n 0~double\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float_not_null","expr":"google.protobuf.FloatValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_float_proto2_null","expr":"TestAllTypes{}.single_float_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_float_proto3_null","expr":"TestAllTypes{}.single_float_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32","expr":"google.protobuf.Int32Value{value: 123} == 123","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int32Value{\n value:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:123~int\n }~wrapper(int)^google.protobuf.Int32Value,\n 123~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32_empty","expr":"google.protobuf.Int32Value{} == 0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32_not_null","expr":"google.protobuf.Int32Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_int32_proto2_null","expr":"TestAllTypes{}.single_int32_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int32_proto3_null","expr":"TestAllTypes{}.single_int32_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64","expr":"google.protobuf.Int64Value{value: 2147483650} == 2147483650","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int64Value{\n value:2147483650^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2147483650^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int64Value{\n value:2147483650~int\n }~wrapper(int)^google.protobuf.Int64Value,\n 2147483650~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64_empty","expr":"google.protobuf.Int64Value{} == 0","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64_not_null","expr":"google.protobuf.Int64Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_int64_proto2_null","expr":"TestAllTypes{}.single_int64_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_int64_proto3_null","expr":"TestAllTypes{}.single_int64_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string","expr":"google.protobuf.StringValue{value: 'set'} == 'set'","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.StringValue{\n value:\"set\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"set\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.StringValue{\n value:\"set\"~string\n }~wrapper(string)^google.protobuf.StringValue,\n \"set\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_empty","expr":"google.protobuf.StringValue{} == ''","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_not_null","expr":"google.protobuf.StringValue{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_string_proto2_null","expr":"TestAllTypes{}.single_string_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_string_proto3_null","expr":"TestAllTypes{}.single_string_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32","expr":"google.protobuf.UInt32Value{value: 42u} == 42u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt32Value{\n value:42u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:42u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n 42u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32_empty","expr":"google.protobuf.UInt32Value{} == 0u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n 0u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32_not_null","expr":"google.protobuf.UInt32Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_uint32_proto2_null","expr":"TestAllTypes{}.single_uint32_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint32_proto3_null","expr":"TestAllTypes{}.single_uint32_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64","expr":"google.protobuf.UInt64Value{value: 4294967296u} == 4294967296u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt64Value{\n value:4294967296u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 4294967296u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt64Value{\n value:4294967296u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value,\n 4294967296u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64_empty","expr":"google.protobuf.UInt64Value{} == 0u","value":{"boolValue":true}},"ast":"_==_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n 0u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64_not_null","expr":"google.protobuf.UInt64Value{} != null","value":{"boolValue":true}},"ast":"_!=_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"eq_uint64_proto2_null","expr":"TestAllTypes{}.single_uint64_wrapper == null","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_uint64_proto3_null","expr":"TestAllTypes{}.single_uint64_wrapper == null","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto_nan_equal","description":"For proto equality, fields with NaN value are treated as not equal.","expr":"TestAllTypes{single_double: double('NaN')} == TestAllTypes{single_double: double('NaN')}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto_different_types","description":"At runtime, differently typed messages are treated as not equal.","expr":"dyn(TestAllTypes{}) == dyn(NestedTestAllTypes{})","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_not_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_bytewise_fallback_not_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto2_any_unpack_bytewise_fallback_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_not_equal","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_bytewise_fallback_not_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"eq_proto3_any_unpack_bytewise_fallback_equal","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"ne_literal","tests":[{"original":{"name":"ne_int","expr":"24 != 42","value":{"boolValue":true}},"ast":"_!=_(\n 24^#*expr.Constant_Int64Value#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 24~int,\n 42~int\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int","expr":"1 != 1","value":{"boolValue":false}},"ast":"_!=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 1~int,\n 1~int\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_int_double","expr":"dyn(24) != 24.1","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 24.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 24.1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int_double","expr":"dyn(1) != 1.0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_int_uint","expr":"dyn(24) != 42u","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 42u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int_uint","expr":"dyn(1) != 1u","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_uint","expr":"1u != 2u","value":{"boolValue":true}},"ast":"_!=_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 1u~uint,\n 2u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_uint","expr":"99u != 99u","value":{"boolValue":false}},"ast":"_!=_(\n 99u^#*expr.Constant_Uint64Value#,\n 99u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 99u~uint,\n 99u~uint\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_uint_double","expr":"dyn(1u) != 2.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_uint_double","expr":"dyn(99u) != 99.0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 99u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 99u~uint\n )~dyn^to_dyn,\n 99~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double","expr":"9.0e+3 != 9001.0","value":{"boolValue":true}},"ast":"_!=_(\n 9000^#*expr.Constant_DoubleValue#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 9000~double,\n 9001~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double_nan","expr":"0.0/0.0 != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_int_double_nan","expr":"dyn(1) != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_uint_double_nan","expr":"dyn(1u) != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double","expr":"1.0 != 1e+0","value":{"boolValue":false}},"ast":"_!=_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n 1~double,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double_int","expr":"dyn(9000) != 9001.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 9000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 9000~int\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double_int","expr":"dyn(1) != 1e+0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double_uint","expr":"dyn(9000u) != 9001.0","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n 9000u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 9000u~uint\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_double_uint","expr":"dyn(1u) != 1e+0","value":{"boolValue":false}},"ast":"_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_double_nan","expr":"0.0/0.0 != 0.0/0.0","value":{"boolValue":true}},"ast":"_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_string","expr":"'abc' != ''","value":{"boolValue":true}},"ast":"_!=_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"abc\"~string,\n \"\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_string","expr":"'abc' != 'abc'","value":{"boolValue":false}},"ast":"_!=_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"abc\"~string,\n \"abc\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_string_unicode","expr":"'résumé' != 'resume'","value":{"boolValue":true}},"ast":"_!=_(\n \"résumé\"^#*expr.Constant_StringValue#,\n \"resume\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"résumé\"~string,\n \"resume\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_string_unicode","expr":"'ίδιο' != 'ίδιο'","value":{"boolValue":false}},"ast":"_!=_(\n \"ίδιο\"^#*expr.Constant_StringValue#,\n \"ίδιο\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n \"ίδιο\"~string,\n \"ίδιο\"~string\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_bytes","expr":"b'\\x00\\xFF' != b'ÿ'","value":{"boolValue":true}},"ast":"_!=_(\n b\"\\x00\\xff\"^#*expr.Constant_BytesValue#,\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n b\"\\x00\\xff\"~bytes,\n b\"ÿ\"~bytes\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_bytes","expr":"b'\\303\\277' != b'ÿ'","value":{"boolValue":false}},"ast":"_!=_(\n b\"ÿ\"^#*expr.Constant_BytesValue#,\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n b\"ÿ\"~bytes,\n b\"ÿ\"~bytes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_bool","expr":"false != true","value":{"boolValue":true}},"ast":"_!=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n false~bool,\n true~bool\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_bool","expr":"true != true","value":{"boolValue":false}},"ast":"_!=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n true~bool,\n true~bool\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_null","description":"null can only be equal to null, or else it won't match","expr":"null != null","value":{"boolValue":false}},"ast":"_!=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n null~null,\n null~null\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_list_empty","expr":"[] != [1]","value":{"boolValue":true}},"ast":"_!=_(\n []^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n []~list(int),\n [\n 1~int\n ]~list(int)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_list_empty","expr":"[] != []","value":{"boolValue":false}},"ast":"_!=_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n []~list(dyn),\n []~list(dyn)\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_list_bool","expr":"[true, false, true] != [true, true, false]","value":{"boolValue":true}},"ast":"_!=_(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n [\n true~bool,\n false~bool,\n true~bool\n ]~list(bool),\n [\n true~bool,\n true~bool,\n false~bool\n ]~list(bool)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_list_bool","expr":"[false, true] != [false, true]","value":{"boolValue":false}},"ast":"_!=_(\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n [\n false~bool,\n true~bool\n ]~list(bool),\n [\n false~bool,\n true~bool\n ]~list(bool)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_list_of_list","expr":"[[]] != [[]]","value":{"boolValue":false}},"ast":"_!=_(\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n [\n []~list(dyn)\n ]~list(list(dyn)),\n [\n []~list(dyn)\n ]~list(list(dyn))\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_map_by_value","expr":"{'k':'v'} != {'k':'v1'}","value":{"boolValue":true}},"ast":"_!=_(\n {\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"k\"~string:\"v\"~string\n }~map(string, string),\n {\n \"k\"~string:\"v1\"~string\n }~map(string, string)\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_map_by_key","expr":"{'k':true} != {'k1':true}","value":{"boolValue":true}},"ast":"_!=_(\n {\n \"k\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"k1\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"k\"~string:true~bool\n }~map(string, bool),\n {\n \"k1\"~string:true~bool\n }~map(string, bool)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_map_int_to_float","expr":"{1:1.0} != {1:1.0}","value":{"boolValue":false}},"ast":"_!=_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n 1~int:1~double\n }~map(int, double),\n {\n 1~int:1~double\n }~map(int, double)\n)~bool^not_equals","type":"bool"},{"original":{"name":"not_ne_map_key_order","expr":"{'a':'b','c':'d'} != {'c':'d','a':'b'}","value":{"boolValue":false}},"ast":"_!=_(\n {\n \"a\"^#*expr.Constant_StringValue#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"c\"^#*expr.Constant_StringValue#:\"d\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n \"c\"^#*expr.Constant_StringValue#:\"d\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"a\"^#*expr.Constant_StringValue#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"a\"~string:\"b\"~string,\n \"c\"~string:\"d\"~string\n }~map(string, string),\n {\n \"c\"~string:\"d\"~string,\n \"a\"~string:\"b\"~string\n }~map(string, string)\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_mixed_types","expr":"2u != 2","disableCheck":true,"value":{"boolValue":false}},"ast":"_!=_(\n 2u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:4: found no matching overload for '_!=_' applied to '(uint, int)'\n | 2u != 2\n | ...^"},{"original":{"name":"ne_proto2","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3","expr":"TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto2_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3_missing_fields_neq","expr":"TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:\"1234\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:\"1234\"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto_nan_not_equal","description":"For proto equality, NaN field values are not considered equal.","expr":"TestAllTypes{single_double: double('NaN')} != TestAllTypes{single_double: double('NaN')}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n \"NaN\"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto_different_types","description":"At runtime, comparing differently typed messages is false.","expr":"dyn(TestAllTypes{}) != dyn(NestedTestAllTypes{})","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_!=_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto2_any_unpack","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto2_any_unpack_bytewise_fallback","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3_any_unpack","description":"Any values should be unpacked and compared.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals","type":"bool"},{"original":{"name":"ne_proto3_any_unpack_bytewise_fallback","description":"If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.","expr":"TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01\"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals","type":"bool"}]},{"name":"lt_literal","tests":[{"original":{"name":"lt_int","expr":"-1 \u003c 0","value":{"boolValue":true}},"ast":"_\u003c_(\n -1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n -1~int,\n 0~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_int","expr":"0 \u003c 0","value":{"boolValue":false}},"ast":"_\u003c_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 0~int,\n 0~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"lt_uint","expr":"0u \u003c 1u","value":{"boolValue":true}},"ast":"_\u003c_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 0u~uint,\n 1u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_uint","expr":"2u \u003c 2u","value":{"boolValue":false}},"ast":"_\u003c_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 2u~uint,\n 2u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_double","expr":"1.0 \u003c 1.0000001","value":{"boolValue":true}},"ast":"_\u003c_(\n 1^#*expr.Constant_DoubleValue#,\n 1.0000001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n 1~double,\n 1.0000001~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_double","description":"Following IEEE 754, negative zero compares equal to zero","expr":"-0.0 \u003c 0.0","value":{"boolValue":false}},"ast":"_\u003c_(\n -0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n -0~double,\n 0~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_string","expr":"'a' \u003c 'b'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"a\"^#*expr.Constant_StringValue#,\n \"b\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"a\"~string,\n \"b\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_empty_to_nonempty","expr":"'' \u003c 'a'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"\"~string,\n \"a\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_case","expr":"'Abc' \u003c 'aBC'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"Abc\"^#*expr.Constant_StringValue#,\n \"aBC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"Abc\"~string,\n \"aBC\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_length","expr":"'abc' \u003c 'abcd'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abcd\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"abc\"~string,\n \"abcd\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_string_diacritical_mark_sensitive","description":"Verifies that the we're not using a string comparison function that strips diacritical marks (á)","expr":"'a' \u003c '\\u00E1'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"a\"^#*expr.Constant_StringValue#,\n \"á\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"a\"~string,\n \"á\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"not_lt_string_empty","expr":"'' \u003c ''","value":{"boolValue":false}},"ast":"_\u003c_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"\"~string,\n \"\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"not_lt_string_same","expr":"'abc' \u003c 'abc'","value":{"boolValue":false}},"ast":"_\u003c_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"abc\"~string,\n \"abc\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"not_lt_string_case_length","expr":"'a' \u003c 'AB'","value":{"boolValue":false}},"ast":"_\u003c_(\n \"a\"^#*expr.Constant_StringValue#,\n \"AB\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"a\"~string,\n \"AB\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"unicode_order_lexical","description":"Compare the actual code points of the string, instead of decomposing ế into 'e' plus accent modifiers.","expr":"'f' \u003c '\\u1EBF'","value":{"boolValue":true}},"ast":"_\u003c_(\n \"f\"^#*expr.Constant_StringValue#,\n \"ế\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n \"f\"~string,\n \"ế\"~string\n)~bool^less_string","type":"bool"},{"original":{"name":"lt_bytes","expr":"b'a' \u003c b'b'","value":{"boolValue":true}},"ast":"_\u003c_(\n b\"a\"^#*expr.Constant_BytesValue#,\n b\"b\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n b\"a\"~bytes,\n b\"b\"~bytes\n)~bool^less_bytes","type":"bool"},{"original":{"name":"not_lt_bytes_same","expr":"b'abc' \u003c b'abc'","value":{"boolValue":false}},"ast":"_\u003c_(\n b\"abc\"^#*expr.Constant_BytesValue#,\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n b\"abc\"~bytes,\n b\"abc\"~bytes\n)~bool^less_bytes","type":"bool"},{"original":{"name":"not_lt_bytes_width","expr":"b'á' \u003c b'b'","value":{"boolValue":false}},"ast":"_\u003c_(\n b\"á\"^#*expr.Constant_BytesValue#,\n b\"b\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n b\"á\"~bytes,\n b\"b\"~bytes\n)~bool^less_bytes","type":"bool"},{"original":{"name":"lt_bool_false_first","expr":"false \u003c true","value":{"boolValue":true}},"ast":"_\u003c_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n false~bool,\n true~bool\n)~bool^less_bool","type":"bool"},{"original":{"name":"not_lt_bool_same","expr":"true \u003c true","value":{"boolValue":false}},"ast":"_\u003c_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n true~bool,\n true~bool\n)~bool^less_bool","type":"bool"},{"original":{"name":"not_lt_bool_true_first","expr":"true \u003c false","value":{"boolValue":false}},"ast":"_\u003c_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n true~bool,\n false~bool\n)~bool^less_bool","type":"bool"},{"original":{"name":"lt_list_unsupported","expr":"[0] \u003c [1]","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c_' applied to '(list(int), list(int))'\n | [0] \u003c [1]\n | ....^"},{"original":{"name":"lt_map_unsupported","expr":"{0:'a'} \u003c {1:'b'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c {1:'b'}\n | ........^"},{"original":{"name":"lt_null_unsupported","description":"Ensure _\u003c_ doesn't have a binding for null","expr":"null \u003c null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n null~null,\n null~null\n)~bool^less_duration|less_timestamp","type":"bool"},{"original":{"name":"lt_mixed_types_error","expr":"'foo' \u003c 1024","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c_' applied to '(string, int)'\n | 'foo' \u003c 1024\n | ......^"},{"original":{"name":"lt_dyn_int_uint","expr":"dyn(1) \u003c 2u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_dyn_int_double","expr":"dyn(1) \u003c 2.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_uint_int","expr":"dyn(1u) \u003c 2","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"lt_dyn_uint_double","expr":"dyn(1u) \u003c 2.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_double_int","expr":"dyn(1.0) \u003c 2","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"lt_dyn_double_uint","expr":"dyn(1.0) \u003c 2u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_int_uint","expr":"dyn(1) \u003c 1u","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_int_double","expr":"dyn(1) \u003c 1.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_uint_int","expr":"dyn(1u) \u003c 1","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_uint_double","expr":"dyn(1u) \u003c 1.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_double_int","expr":"dyn(1.0) \u003c 1","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_double_uint","expr":"dyn(1.0) \u003c 1u","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_dyn_int_big_uint","expr":"dyn(1) \u003c 9223372036854775808u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"lt_dyn_small_int_uint","expr":"dyn(-1) \u003c 0u","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_int_big_lossy_double","expr":"dyn(9223372036854775807) \u003c 9223372036854775808.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_int_big_lossy_double","expr":"dyn(9223372036854775807) \u003c 9223372036854777857.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_int_small_double","expr":"dyn(9223372036854775807) \u003c -9223372036854777857.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_int_small_lossy_double","expr":"dyn(-9223372036854775808) \u003c -9223372036854775809.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_uint_small_int","expr":"dyn(1u) \u003c -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003c 1","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_uint_small_double","expr":"dyn(18446744073709551615u) \u003c -1.0","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_double","type":"bool"},{"original":{"name":"lt_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003c 18446744073709590000.0","value":{"boolValue":true}},"ast":"_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_double","type":"bool"},{"original":{"name":"not_lt_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003c 18446744073709551615u","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_uint64","type":"bool"},{"original":{"name":"not_lt_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003c 9223372036854775807","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_int64","type":"bool"},{"original":{"name":"not_lt_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003c -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003c_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64","type":"bool"}]},{"name":"gt_literal","tests":[{"original":{"name":"gt_int","expr":"42 \u003e -42","value":{"boolValue":true}},"ast":"_\u003e_(\n 42^#*expr.Constant_Int64Value#,\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 42~int,\n -42~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_int","expr":"0 \u003e 0","value":{"boolValue":false}},"ast":"_\u003e_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 0~int,\n 0~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_uint","expr":"48u \u003e 46u","value":{"boolValue":true}},"ast":"_\u003e_(\n 48u^#*expr.Constant_Uint64Value#,\n 46u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 48u~uint,\n 46u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_uint","expr":"0u \u003e 999u","value":{"boolValue":false}},"ast":"_\u003e_(\n 0u^#*expr.Constant_Uint64Value#,\n 999u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 0u~uint,\n 999u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"gt_double","expr":"1e+1 \u003e 1e+0","value":{"boolValue":true}},"ast":"_\u003e_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 10~double,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_double","expr":".99 \u003e 9.9e-1","value":{"boolValue":false}},"ast":"_\u003e_(\n 0.99^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n 0.99~double,\n 0.99~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_string_case","expr":"'abc' \u003e 'aBc'","value":{"boolValue":true}},"ast":"_\u003e_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"aBc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"abc\"~string,\n \"aBc\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"gt_string_to_empty","expr":"'A' \u003e ''","value":{"boolValue":true}},"ast":"_\u003e_(\n \"A\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"A\"~string,\n \"\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"not_gt_string_empty_to_empty","expr":"'' \u003e ''","value":{"boolValue":false}},"ast":"_\u003e_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"\"~string,\n \"\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"gt_string_unicode","expr":"'α' \u003e 'omega'","value":{"boolValue":true}},"ast":"_\u003e_(\n \"α\"^#*expr.Constant_StringValue#,\n \"omega\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n \"α\"~string,\n \"omega\"~string\n)~bool^greater_string","type":"bool"},{"original":{"name":"gt_bytes_one","expr":"b'\u0001' \u003e b'\u0000'","value":{"boolValue":true}},"ast":"_\u003e_(\n b\"\\x01\"^#*expr.Constant_BytesValue#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n b\"\\x01\"~bytes,\n b\"\\x00\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"gt_bytes_one_to_empty","expr":"b'\u0000' \u003e b''","value":{"boolValue":true}},"ast":"_\u003e_(\n b\"\\x00\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n b\"\\x00\"~bytes,\n b\"\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"not_gt_bytes_sorting","expr":"b'\u0000\u0001' \u003e b'\u0001'","value":{"boolValue":false}},"ast":"_\u003e_(\n b\"\\x00\\x01\"^#*expr.Constant_BytesValue#,\n b\"\\x01\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n b\"\\x00\\x01\"~bytes,\n b\"\\x01\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"gt_bool_true_false","expr":"true \u003e false","value":{"boolValue":true}},"ast":"_\u003e_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n true~bool,\n false~bool\n)~bool^greater_bool","type":"bool"},{"original":{"name":"not_gt_bool_false_true","expr":"false \u003e true","value":{"boolValue":false}},"ast":"_\u003e_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n false~bool,\n true~bool\n)~bool^greater_bool","type":"bool"},{"original":{"name":"not_gt_bool_same","expr":"true \u003e true","value":{"boolValue":false}},"ast":"_\u003e_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n true~bool,\n true~bool\n)~bool^greater_bool","type":"bool"},{"original":{"name":"gt_null_unsupported","expr":"null \u003e null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n null~null,\n null~null\n)~bool^greater_duration|greater_timestamp","type":"bool"},{"original":{"name":"gt_list_unsupported","expr":"[1] \u003e [0]","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003e_' applied to '(list(int), list(int))'\n | [1] \u003e [0]\n | ....^"},{"original":{"name":"gt_map_unsupported","expr":"{1:'b'} \u003e {0:'a'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e {0:'a'}\n | ........^"},{"original":{"name":"gt_mixed_types_error","expr":"'foo' \u003e 1024","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e_' applied to '(string, int)'\n | 'foo' \u003e 1024\n | ......^"},{"original":{"name":"gt_dyn_int_uint","expr":"dyn(2) \u003e 1u","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"gt_dyn_int_double","expr":"dyn(2) \u003e 1.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_uint_int","expr":"dyn(2u) \u003e 1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_uint_double","expr":"dyn(2u) \u003e 1.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_double_int","expr":"dyn(2.0) \u003e 1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_double_uint","expr":"dyn(2.0) \u003e 1u","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_uint","expr":"dyn(1) \u003e 1u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_double","expr":"dyn(1) \u003e 1.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_uint_int","expr":"dyn(1u) \u003e 1","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_dyn_uint_double","expr":"dyn(1u) \u003e 1.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_double_int","expr":"dyn(1.0) \u003e 1","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_dyn_double_uint","expr":"dyn(1.0) \u003e 1u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_big_uint","expr":"dyn(1) \u003e 9223372036854775808u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_small_int_uint","expr":"dyn(-1) \u003e 0u","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_int_big_double","expr":"dyn(9223372036854775807) \u003e 9223372036854775808.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_int_small_lossy_double","description":"The conversion of the int to double is lossy and the numbers end up being equal","expr":"dyn(-9223372036854775808) \u003e -9223372036854775809.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_int_small_lossy_double_greater","expr":"dyn(-9223372036854775808) \u003e -9223372036854777857.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_uint_small_int","expr":"dyn(1u) \u003e -1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003e 1","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"gt_dyn_uint_small_double","expr":"dyn(9223372036854775807u) \u003e -1.0","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"not_gt_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003e 18446744073709590000.0","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^greater_double","type":"bool"},{"original":{"name":"gt_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003e 18446744073709551615u","value":{"boolValue":true}},"ast":"_\u003e_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_uint64","type":"bool"},{"original":{"name":"not_gt_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003e 9223372036854775807","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_int64","type":"bool"},{"original":{"name":"not_gt_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003e -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003e_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_int64","type":"bool"}]},{"name":"lte_literal","tests":[{"original":{"name":"lte_int_lt","expr":"0 \u003c= 1","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0~int,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_int_eq","expr":"1 \u003c= 1","value":{"boolValue":true}},"ast":"_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1~int,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_int_gt","expr":"1 \u003c= -1","value":{"boolValue":false}},"ast":"_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1~int,\n -1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_uint_lt","expr":"0u \u003c= 1u","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0u~uint,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_uint_eq","expr":"1u \u003c= 1u","value":{"boolValue":true}},"ast":"_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1u~uint,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"not_lte_uint_gt","expr":"1u \u003c= 0u","value":{"boolValue":false}},"ast":"_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1u~uint,\n 0u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_double_lt","expr":"0.0 \u003c= 0.1e-31","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 1e-32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0~double,\n 1e-32~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_double_eq","expr":"0.0 \u003c= 0e-1","value":{"boolValue":true}},"ast":"_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 0~double,\n 0~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_double_gt","expr":"1.0 \u003c= 0.99","value":{"boolValue":false}},"ast":"_\u003c=_(\n 1^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 1~double,\n 0.99~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_string_empty","expr":"'' \u003c= ''","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"\"~string,\n \"\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_from_empty","expr":"'' \u003c= 'a'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"\"~string,\n \"a\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"not_lte_string_to_empty","expr":"'a' \u003c= ''","value":{"boolValue":false}},"ast":"_\u003c=_(\n \"a\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"a\"~string,\n \"\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_lexicographical","expr":"'aBc' \u003c= 'abc'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"aBc\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"aBc\"~string,\n \"abc\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_unicode_eq","expr":"'α' \u003c= 'α'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"α\"^#*expr.Constant_StringValue#,\n \"α\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"α\"~string,\n \"α\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_string_unicode_lt","expr":"'a' \u003c= 'α'","value":{"boolValue":true}},"ast":"_\u003c=_(\n \"a\"^#*expr.Constant_StringValue#,\n \"α\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"a\"~string,\n \"α\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"not_lte_string_unicode","expr":"'α' \u003c= 'a'","value":{"boolValue":false}},"ast":"_\u003c=_(\n \"α\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n \"α\"~string,\n \"a\"~string\n)~bool^less_equals_string","type":"bool"},{"original":{"name":"lte_bytes_empty","expr":"b'' \u003c= b'\u0000'","value":{"boolValue":true}},"ast":"_\u003c=_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n b\"\"~bytes,\n b\"\\x00\"~bytes\n)~bool^less_equals_bytes","type":"bool"},{"original":{"name":"not_lte_bytes_length","expr":"b'\u0001\u0000' \u003c= b'\u0001'","value":{"boolValue":false}},"ast":"_\u003c=_(\n b\"\\x01\\x00\"^#*expr.Constant_BytesValue#,\n b\"\\x01\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n b\"\\x01\\x00\"~bytes,\n b\"\\x01\"~bytes\n)~bool^less_equals_bytes","type":"bool"},{"original":{"name":"lte_bool_false_true","expr":"false \u003c= true","value":{"boolValue":true}},"ast":"_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n false~bool,\n true~bool\n)~bool^less_equals_bool","type":"bool"},{"original":{"name":"lte_bool_false_false","expr":"false \u003c= false","value":{"boolValue":true}},"ast":"_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n false~bool,\n false~bool\n)~bool^less_equals_bool","type":"bool"},{"original":{"name":"lte_bool_true_false","expr":"true \u003c= false","value":{"boolValue":false}},"ast":"_\u003c=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n true~bool,\n false~bool\n)~bool^less_equals_bool","type":"bool"},{"original":{"name":"lte_null_unsupported","expr":"null \u003c= null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n null~null,\n null~null\n)~bool^less_equals_duration|less_equals_timestamp","type":"bool"},{"original":{"name":"lte_list_unsupported","expr":"[0] \u003c= [0]","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c=_' applied to '(list(int), list(int))'\n | [0] \u003c= [0]\n | ....^"},{"original":{"name":"lte_map_unsupported","expr":"{0:'a'} \u003c= {1:'b'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c=_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c= {1:'b'}\n | ........^"},{"original":{"name":"lte_mixed_types_error","expr":"'foo' \u003c= 1024","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c=_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c=_' applied to '(string, int)'\n | 'foo' \u003c= 1024\n | ......^"},{"original":{"name":"lte_dyn_int_uint","expr":"dyn(1) \u003c= 2u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_int_double","expr":"dyn(1) \u003c= 2.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_uint_int","expr":"dyn(1u) \u003c= 2","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_dyn_uint_double","expr":"dyn(1u) \u003c= 2.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_double_int","expr":"dyn(1.0) \u003c= 2","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_dyn_double_uint","expr":"dyn(1.0) \u003c= 2u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"not_lte_dyn_int_uint","expr":"dyn(2) \u003c= 1u","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"not_lte_dyn_int_double","expr":"dyn(2) \u003c= 1.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_uint_int","expr":"dyn(2u) \u003c= 1","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_uint_double","expr":"dyn(2u) \u003c= 1.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_double_int","expr":"dyn(2.0) \u003c= 1","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_double_uint","expr":"dyn(2.0) \u003c= 1u","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_int_big_uint","expr":"dyn(1) \u003c= 9223372036854775808u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_small_int_uint","expr":"dyn(-1) \u003c= 0u","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_int_big_double","expr":"dyn(9223372036854775807) \u003c= 9223372036854775808.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_int_small_lossy_double","description":"The conversion of the int to double is lossy and the numbers end up being equal","expr":"dyn(-9223372036854775808) \u003c= -9223372036854775809.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_int_small_lossy_double_less","expr":"dyn(-9223372036854775808) \u003c= -9223372036854777857.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_uint_small_int","expr":"dyn(1u) \u003c= -9223372036854775808","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003c= 1","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"not_lte_dyn_uint_small_double","expr":"dyn(18446744073709551615u) \u003c= -1.0","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"lte_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003c= 18446744073709590000.0","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_equals_double","type":"bool"},{"original":{"name":"not_lte_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003c= 18446744073709551615u","value":{"boolValue":false}},"ast":"_\u003c=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_equals_uint64","type":"bool"},{"original":{"name":"lte_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003c= 9223372036854775807","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"lte_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003c= -9223372036854775808","value":{"boolValue":true}},"ast":"_\u003c=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64","type":"bool"}]},{"name":"gte_literal","tests":[{"original":{"name":"gte_int_gt","expr":"0 \u003e= -1","value":{"boolValue":true}},"ast":"_\u003e=_(\n 0^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 0~int,\n -1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_int_eq","expr":"999 \u003e= 999","value":{"boolValue":true}},"ast":"_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 999^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 999~int,\n 999~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"not_gte_int_lt","expr":"999 \u003e= 1000","value":{"boolValue":false}},"ast":"_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 1000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 999~int,\n 1000~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_uint_gt","expr":"1u \u003e= 0u","value":{"boolValue":true}},"ast":"_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 1u~uint,\n 0u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_uint_eq","expr":"0u \u003e= 0u","value":{"boolValue":true}},"ast":"_\u003e=_(\n 0u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 0u~uint,\n 0u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_uint_lt","expr":"1u \u003e= 10u","value":{"boolValue":false}},"ast":"_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 1u~uint,\n 10u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_double_gt","expr":"1e+1 \u003e= 1e+0","value":{"boolValue":true}},"ast":"_\u003e=_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 10~double,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_double_eq","expr":"9.80665 \u003e= 9.80665e+0","value":{"boolValue":true}},"ast":"_\u003e=_(\n 9.80665^#*expr.Constant_DoubleValue#,\n 9.80665^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 9.80665~double,\n 9.80665~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_double_lt","expr":"0.9999 \u003e= 1.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n 0.9999^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n 0.9999~double,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_string_empty","expr":"'' \u003e= ''","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"\"~string,\n \"\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_to_empty","expr":"'a' \u003e= ''","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"a\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"a\"~string,\n \"\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_empty_to_nonempty","expr":"'' \u003e= 'a'","value":{"boolValue":false}},"ast":"_\u003e=_(\n \"\"^#*expr.Constant_StringValue#,\n \"a\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"\"~string,\n \"a\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_length","expr":"'abcd' \u003e= 'abc'","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"abcd\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"abcd\"~string,\n \"abc\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"not_gte_string_lexicographical","expr":"'abc' \u003e= 'abd'","value":{"boolValue":false}},"ast":"_\u003e=_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"abd\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"abc\"~string,\n \"abd\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_unicode_eq","expr":"'τ' \u003e= 'τ'","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"τ\"^#*expr.Constant_StringValue#,\n \"τ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"τ\"~string,\n \"τ\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_string_unicode_gt","expr":"'τ' \u003e= 't'","value":{"boolValue":true}},"ast":"_\u003e=_(\n \"τ\"^#*expr.Constant_StringValue#,\n \"t\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"τ\"~string,\n \"t\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"not_get_string_unicode","expr":"'t' \u003e= 'τ'","value":{"boolValue":false}},"ast":"_\u003e=_(\n \"t\"^#*expr.Constant_StringValue#,\n \"τ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"t\"~string,\n \"τ\"~string\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"gte_bytes_to_empty","expr":"b'\u0000' \u003e= b''","value":{"boolValue":true}},"ast":"_\u003e=_(\n b\"\\x00\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n b\"\\x00\"~bytes,\n b\"\"~bytes\n)~bool^greater_equals_bytes","type":"bool"},{"original":{"name":"not_gte_bytes_empty_to_nonempty","expr":"b'' \u003e= b'\u0000'","value":{"boolValue":false}},"ast":"_\u003e=_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n b\"\"~bytes,\n b\"\\x00\"~bytes\n)~bool^greater_equals_bytes","type":"bool"},{"original":{"name":"gte_bytes_samelength","expr":"b'\u0000\u0001' \u003e= b'\u0001\u0000'","value":{"boolValue":false}},"ast":"_\u003e=_(\n b\"\\x00\\x01\"^#*expr.Constant_BytesValue#,\n b\"\\x01\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n b\"\\x00\\x01\"~bytes,\n b\"\\x01\\x00\"~bytes\n)~bool^greater_equals_bytes","type":"bool"},{"original":{"name":"gte_bool_gt","expr":"true \u003e= false","value":{"boolValue":true}},"ast":"_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n true~bool,\n false~bool\n)~bool^greater_equals_bool","type":"bool"},{"original":{"name":"gte_bool_eq","expr":"true \u003e= true","value":{"boolValue":true}},"ast":"_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n true~bool,\n true~bool\n)~bool^greater_equals_bool","type":"bool"},{"original":{"name":"not_gte_bool_lt","expr":"false \u003e= true","value":{"boolValue":false}},"ast":"_\u003e=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n false~bool,\n true~bool\n)~bool^greater_equals_bool","type":"bool"},{"original":{"name":"gte_null_unsupported","expr":"null \u003e= null","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n null~null,\n null~null\n)~bool^greater_equals_duration|greater_equals_timestamp","type":"bool"},{"original":{"name":"gte_list_unsupported","expr":"['y'] \u003e= ['x']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n [\n \"y\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n \"x\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(list(string), list(string))'\n | ['y'] \u003e= ['x']\n | ......^"},{"original":{"name":"gte_map_unsupported","expr":"{1:'b'} \u003e= {0:'a'}","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n {\n 1^#*expr.Constant_Int64Value#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e=_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e= {0:'a'}\n | ........^"},{"original":{"name":"gte_mixed_types_error","expr":"'foo' \u003e= 1.0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003e=_(\n \"foo\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(string, double)'\n | 'foo' \u003e= 1.0\n | ......^"},{"original":{"name":"gte_dyn_int_uint","expr":"dyn(2) \u003e= 1u","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_dyn_int_double","expr":"dyn(2) \u003e= 1.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_uint_int","expr":"dyn(2u) \u003e= 1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_uint_double","expr":"dyn(2u) \u003e= 1.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_double_int","expr":"dyn(2.0) \u003e= 1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_double_uint","expr":"dyn(2.0) \u003e= 1u","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_int_uint","expr":"dyn(0) \u003e= 1u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_int_double","expr":"dyn(0) \u003e= 1.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_uint_int","expr":"dyn(0u) \u003e= 1","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"not_gte_dyn_uint_double","expr":"dyn(0u) \u003e= 1.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_double_int","expr":"dyn(0.0) \u003e= 1","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"not_gte_dyn_double_uint","expr":"dyn(0.0) \u003e= 1u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_int_big_uint","expr":"dyn(1) \u003e= 9223372036854775808u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"not_gte_dyn_small_int_uint","expr":"dyn(-1) \u003e= 0u","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_dyn_int_big_lossy_double","expr":"dyn(9223372036854775807) \u003e= 9223372036854775808.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_int_big_double","expr":"dyn(9223372036854775807) \u003e= 9223372036854777857.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_int_small_lossy_double_equal","description":"The conversion of the int to double is lossy and the numbers end up being equal","expr":"dyn(-9223372036854775808) \u003e= -9223372036854775809.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_int_small_lossy_double_greater","expr":"dyn(-9223372036854775808) \u003e= -9223372036854777857.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_uint_small_int","expr":"dyn(1u) \u003e= -1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_big_uint_int","expr":"dyn(9223372036854775808u) \u003e= 1","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_uint_small_double","expr":"dyn(9223372036854775807u) \u003e= -1.0","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"not_gte_dyn_uint_big_double","expr":"dyn(18446744073709551615u) \u003e= 18446744073709553665.0","value":{"boolValue":false}},"ast":"_\u003e=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.8446744073709556e+19~double\n)~bool^greater_equals_double","type":"bool"},{"original":{"name":"gte_dyn_big_double_uint","expr":"dyn(18446744073709553665.0) \u003e= 18446744073709551615u","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_equals_uint64","type":"bool"},{"original":{"name":"gte_dyn_big_double_int","expr":"dyn(9223372036854775808.0) \u003e= 9223372036854775807","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_equals_int64","type":"bool"},{"original":{"name":"gte_dyn_small_double_int","expr":"dyn(-9223372036854775809.0) \u003e= -9223372036854775808","value":{"boolValue":true}},"ast":"_\u003e=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_equals_int64","type":"bool"}]},{"name":"in_list_literal","tests":[{"original":{"name":"elem_not_in_empty_list","expr":"'empty' in []","value":{"boolValue":false}},"ast":"@in(\n \"empty\"^#*expr.Constant_StringValue#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"empty\"~string,\n []~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_in_list","expr":"'elem' in ['elem', 'elemA', 'elemB']","value":{"boolValue":true}},"ast":"@in(\n \"elem\"^#*expr.Constant_StringValue#,\n [\n \"elem\"^#*expr.Constant_StringValue#,\n \"elemA\"^#*expr.Constant_StringValue#,\n \"elemB\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"elem\"~string,\n [\n \"elem\"~string,\n \"elemA\"~string,\n \"elemB\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_not_in_list","expr":"'not' in ['elem1', 'elem2', 'elem3']","value":{"boolValue":false}},"ast":"@in(\n \"not\"^#*expr.Constant_StringValue#,\n [\n \"elem1\"^#*expr.Constant_StringValue#,\n \"elem2\"^#*expr.Constant_StringValue#,\n \"elem3\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"not\"~string,\n [\n \"elem1\"~string,\n \"elem2\"~string,\n \"elem3\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_in_mixed_type_list","description":"Set membership tests should succeed if the 'elem' exists in a mixed element type list.","expr":"'elem' in [1, 'elem', 2]","value":{"boolValue":true}},"ast":"@in(\n \"elem\"^#*expr.Constant_StringValue#,\n [\n 1^#*expr.Constant_Int64Value#,\n \"elem\"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"elem\"~string,\n [\n 1~int,\n \"elem\"~string,\n 2~int\n ]~list(dyn)\n)~bool^in_list","type":"bool"},{"original":{"name":"elem_in_mixed_type_list_cross_type","description":"Set membership tests should return false due to the introduction of heterogeneous-equality. Set membership via 'in' is equivalent to the macro exists() behavior.","expr":"'elem' in [1u, 'str', 2, b'bytes']","value":{"boolValue":false}},"ast":"@in(\n \"elem\"^#*expr.Constant_StringValue#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n \"str\"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#,\n b\"bytes\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"elem\"~string,\n [\n 1u~uint,\n \"str\"~string,\n 2~int,\n b\"bytes\"~bytes\n ]~list(dyn)\n)~bool^in_list","type":"bool"}]},{"name":"in_map_literal","tests":[{"original":{"name":"key_not_in_empty_map","expr":"'empty' in {}","value":{"boolValue":false}},"ast":"@in(\n \"empty\"^#*expr.Constant_StringValue#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"empty\"~string,\n {}~map(string, dyn)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_in_map","expr":"'key' in {'key':'1', 'other':'2'}","value":{"boolValue":true}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n \"key\"^#*expr.Constant_StringValue#:\"1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"other\"^#*expr.Constant_StringValue#:\"2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n \"key\"~string:\"1\"~string,\n \"other\"~string:\"2\"~string\n }~map(string, string)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_not_in_map","expr":"'key' in {'lock':1, 'gate':2}","value":{"boolValue":false}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n \"lock\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"gate\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n \"lock\"~string:1~int,\n \"gate\"~string:2~int\n }~map(string, int)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_in_mixed_key_type_map","description":"Map keys are of mixed type, but since the key is present the result is true.","expr":"'key' in {3:3.0, 'key':2u}","value":{"boolValue":true}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n 3^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key\"^#*expr.Constant_StringValue#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n 3~int:3~double,\n \"key\"~string:2u~uint\n }~map(dyn, dyn)\n)~bool^in_map","type":"bool"},{"original":{"name":"key_in_mixed_key_type_map_cross_type","expr":"'key' in {1u:'str', 2:b'bytes'}","value":{"boolValue":false}},"ast":"@in(\n \"key\"^#*expr.Constant_StringValue#,\n {\n 1u^#*expr.Constant_Uint64Value#:\"str\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:b\"bytes\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"key\"~string,\n {\n 1u~uint:\"str\"~string,\n 2~int:b\"bytes\"~bytes\n }~map(dyn, dyn)\n)~bool^in_map","type":"bool"}]},{"name":"bound","tests":[{"original":{"name":"bytes_gt_left_false","expr":"x \u003e b'\u0000'","typeEnv":[{"name":"x","ident":{"type":{"primitive":"BYTES"}}}],"bindings":{"x":{"value":{"bytesValue":"AA=="}}},"value":{"boolValue":false}},"ast":"_\u003e_(\n x^#*expr.Expr_IdentExpr#,\n b\"\\x00\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n x~bytes^x,\n b\"\\x00\"~bytes\n)~bool^greater_bytes","type":"bool"},{"original":{"name":"int_lte_right_true","expr":"123 \u003c= x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"x":{"value":{"int64Value":"124"}}},"value":{"boolValue":true}},"ast":"_\u003c=_(\n 123^#*expr.Constant_Int64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n 123~int,\n x~int^x\n)~bool^less_equals_int64","type":"bool"},{"original":{"name":"bool_lt_right_true","expr":"false \u003c x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"x":{"value":{"boolValue":true}}},"value":{"boolValue":true}},"ast":"_\u003c_(\n false^#*expr.Constant_BoolValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n false~bool,\n x~bool^x\n)~bool^less_bool","type":"bool"},{"original":{"name":"double_ne_left_false","expr":"x != 9.8","typeEnv":[{"name":"x","ident":{"type":{"primitive":"DOUBLE"}}}],"bindings":{"x":{"value":{"doubleValue":9.8}}},"value":{"boolValue":false}},"ast":"_!=_(\n x^#*expr.Expr_IdentExpr#,\n 9.8^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n x~double^x,\n 9.8~double\n)~bool^not_equals","type":"bool"},{"original":{"name":"map_ne_right_false","expr":"{'a':'b','c':'d'} != x","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"d"}},{"key":{"stringValue":"a"},"value":{"stringValue":"b"}}]}}}},"value":{"boolValue":false}},"ast":"_!=_(\n {\n \"a\"^#*expr.Constant_StringValue#:\"b\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"c\"^#*expr.Constant_StringValue#:\"d\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n {\n \"a\"~string:\"b\"~string,\n \"c\"~string:\"d\"~string\n }~map(string, string),\n x~map(string, string)^x\n)~bool^not_equals","type":"bool"},{"original":{"name":"null_eq_left_true","description":"A comparison _==_ against null only binds if the type is determined to be null or we skip the type checking","expr":"x == null","typeEnv":[{"name":"x","ident":{"type":{"null":null}}}],"bindings":{"x":{"value":{"nullValue":null}}},"value":{"boolValue":true}},"ast":"_==_(\n x^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n x~null^x,\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"list_eq_right_false","expr":"[1, 2] == x","typeEnv":[{"name":"x","ident":{"type":{"listType":{"elemType":{"primitive":"INT64"}}}}}],"bindings":{"x":{"value":{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"1"}]}}}},"value":{"boolValue":false}},"ast":"_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n 1~int,\n 2~int\n ]~list(int),\n x~list(int)^x\n)~bool^equals","type":"bool"},{"original":{"name":"string_gte_right_true","expr":"'abcd' \u003e= x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"x":{"value":{"stringValue":"abc"}}},"value":{"boolValue":true}},"ast":"_\u003e=_(\n \"abcd\"^#*expr.Constant_StringValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n \"abcd\"~string,\n x~string^x\n)~bool^greater_equals_string","type":"bool"},{"original":{"name":"uint_eq_right_false","expr":"999u == x","typeEnv":[{"name":"x","ident":{"type":{"primitive":"UINT64"}}}],"bindings":{"x":{"value":{"uint64Value":"1000"}}},"value":{"boolValue":false}},"ast":"_==_(\n 999u^#*expr.Constant_Uint64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n 999u~uint,\n x~uint^x\n)~bool^equals","type":"bool"},{"original":{"name":"null_lt_right_no_such_overload","description":"There is no _\u003c_ operation for null, even if both operands are null","expr":"null \u003c x","disableCheck":true,"bindings":{"x":{"value":{"nullValue":null}}},"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_\u003c_(\n null^#*expr.Constant_NullValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:8: undeclared reference to 'x' (in container '')\n | null \u003c x\n | .......^"}]}]},{"name":"conversions","suites":[{"name":"bytes","tests":[{"original":{"name":"string_empty","expr":"bytes('')","value":{"bytesValue":""}},"ast":"bytes(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n \"\"~string\n)~bytes^string_to_bytes","type":"bytes"},{"original":{"name":"string","expr":"bytes('abc')","value":{"bytesValue":"YWJj"}},"ast":"bytes(\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n \"abc\"~string\n)~bytes^string_to_bytes","type":"bytes"},{"original":{"name":"string_unicode","expr":"bytes('ÿ')","value":{"bytesValue":"w78="}},"ast":"bytes(\n \"ÿ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n \"ÿ\"~string\n)~bytes^string_to_bytes","type":"bytes"},{"original":{"name":"string_unicode_vs_literal","expr":"bytes('\\377') == b'\\377'","value":{"boolValue":false}},"ast":"_==_(\n bytes(\n \"ÿ\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n b\"\\xff\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n bytes(\n \"ÿ\"~string\n )~bytes^string_to_bytes,\n b\"\\xff\"~bytes\n)~bool^equals","type":"bool"}]},{"name":"double","tests":[{"original":{"name":"int_zero","expr":"double(0)","value":{"doubleValue":0}},"ast":"double(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 0~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_pos","expr":"double(1000000000000)","value":{"doubleValue":1000000000000}},"ast":"double(\n 1000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 1000000000000~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_neg","expr":"double(-1000000000000000)","value":{"doubleValue":-1000000000000000}},"ast":"double(\n -1000000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n -1000000000000000~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_min_exact","description":"Smallest contiguous representable int (-2^53).","expr":"double(-9007199254740992)","value":{"doubleValue":-9007199254740992}},"ast":"double(\n -9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n -9007199254740992~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_max_exact","description":"Largest contiguous representable int (2^53).","expr":"double(9007199254740992)","value":{"doubleValue":9007199254740992}},"ast":"double(\n 9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 9007199254740992~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"int_range","description":"Largest signed 64-bit. Rounds to nearest double.","expr":"double(9223372036854775807)","value":{"doubleValue":9223372036854776000}},"ast":"double(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 9223372036854775807~int\n)~double^int64_to_double","type":"double"},{"original":{"name":"uint_zero","expr":"double(0u)","value":{"doubleValue":0}},"ast":"double(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 0u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"uint_pos","expr":"double(123u)","value":{"doubleValue":123}},"ast":"double(\n 123u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 123u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"uint_max_exact","description":"Largest contiguous representable int (2^53).","expr":"double(9007199254740992u)","value":{"doubleValue":9007199254740992}},"ast":"double(\n 9007199254740992u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 9007199254740992u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"uint_range","description":"Largest unsigned 64-bit.","expr":"double(18446744073709551615u)","value":{"doubleValue":18446744073709552000}},"ast":"double(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 18446744073709551615u~uint\n)~double^uint64_to_double","type":"double"},{"original":{"name":"string_zero","expr":"double('0')","value":{"doubleValue":0}},"ast":"double(\n \"0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"0\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_zero_dec","expr":"double('0.0')","value":{"doubleValue":0}},"ast":"double(\n \"0.0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"0.0\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_neg_zero","expr":"double('-0.0')","value":{"doubleValue":0}},"ast":"double(\n \"-0.0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-0.0\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_no_dec","expr":"double('123')","value":{"doubleValue":123}},"ast":"double(\n \"123\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"123\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_pos","expr":"double('123.456')","value":{"doubleValue":123.456}},"ast":"double(\n \"123.456\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"123.456\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_neg","expr":"double('-987.654')","value":{"doubleValue":-987.654}},"ast":"double(\n \"-987.654\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-987.654\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_pos_pos","expr":"double('6.02214e23')","value":{"doubleValue":6.02214e+23}},"ast":"double(\n \"6.02214e23\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"6.02214e23\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_pos_neg","expr":"double('1.38e-23')","value":{"doubleValue":1.38e-23}},"ast":"double(\n \"1.38e-23\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"1.38e-23\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_neg_pos","expr":"double('-84.32e7')","value":{"doubleValue":-843200000}},"ast":"double(\n \"-84.32e7\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-84.32e7\"~string\n)~double^string_to_double","type":"double"},{"original":{"name":"string_exp_neg_neg","expr":"double('-5.43e-21')","value":{"doubleValue":-5.43e-21}},"ast":"double(\n \"-5.43e-21\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n \"-5.43e-21\"~string\n)~double^string_to_double","type":"double"}]},{"name":"dyn","tests":[{"original":{"name":"dyn_heterogeneous_list","description":"No need to disable type checking.","expr":"type(dyn([1, 'one']))","value":{"typeValue":"list"}},"ast":"type(\n dyn(\n [\n 1^#*expr.Constant_Int64Value#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n dyn(\n [\n 1~int,\n \"one\"~string\n ]~list(dyn)\n )~dyn^to_dyn\n)~type(dyn)^type","type":"type(dyn)"}]},{"name":"int","tests":[{"original":{"name":"uint","expr":"int(42u)","value":{"int64Value":"42"}},"ast":"int(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 42u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"uint_zero","expr":"int(0u)","value":{"int64Value":"0"}},"ast":"int(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 0u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"uint_max_exact","expr":"int(9223372036854775807u)","value":{"int64Value":"9223372036854775807"}},"ast":"int(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 9223372036854775807u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"uint_range","expr":"int(18446744073709551615u)","evalError":{"errors":[{"message":"range error"}]}},"ast":"int(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 18446744073709551615u~uint\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"double_round_neg","expr":"int(-123.456)","value":{"int64Value":"-123"}},"ast":"int(\n -123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -123.456~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_truncate","expr":"int(1.9)","value":{"int64Value":"1"}},"ast":"int(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1.9~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_truncate_neg","expr":"int(-7.9)","value":{"int64Value":"-7"}},"ast":"int(\n -7.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -7.9~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_half_pos","expr":"int(11.5)","value":{"int64Value":"11"}},"ast":"int(\n 11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 11.5~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_half_neg","expr":"int(-3.5)","value":{"int64Value":"-3"}},"ast":"int(\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -3.5~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_big_exact","description":"Beyond exact range (2^53), but no loss of precision (2^55).","expr":"int(double(36028797018963968))","value":{"int64Value":"36028797018963968"}},"ast":"int(\n double(\n 36028797018963968^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n double(\n 36028797018963968~int\n )~double^int64_to_double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_big_precision","description":"Beyond exact range (2^53), but loses precision (2^55 + 1).","expr":"int(double(36028797018963969))","value":{"int64Value":"36028797018963968"}},"ast":"int(\n double(\n 36028797018963969^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n double(\n 36028797018963969~int\n )~double^int64_to_double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_int_max_range","description":"The double(2^63-1) cast produces a floating point value outside the int range","expr":"int(9223372036854775807.0)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 9.223372036854776e+18~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_int_min_range","description":"The double(-2^63) cast produces a floating point value outside the int range","expr":"int(-9223372036854775808.0)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n -9.223372036854776e+18~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_range","expr":"int(1e99)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n 1e+99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1e+99~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"string","expr":"int('987')","value":{"int64Value":"987"}},"ast":"int(\n \"987\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n \"987\"~string\n)~int^string_to_int64","type":"int"},{"original":{"name":"timestamp","expr":"int(timestamp('2004-09-16T23:59:59Z'))","value":{"int64Value":"1095379199"}},"ast":"int(\n timestamp(\n \"2004-09-16T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n timestamp(\n \"2004-09-16T23:59:59Z\"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64","type":"int"}]},{"name":"string","tests":[{"original":{"name":"int","expr":"string(123)","value":{"stringValue":"123"}},"ast":"string(\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n 123~int\n)~string^int64_to_string","type":"string"},{"original":{"name":"int_neg","expr":"string(-456)","value":{"stringValue":"-456"}},"ast":"string(\n -456^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n -456~int\n)~string^int64_to_string","type":"string"},{"original":{"name":"uint","expr":"string(9876u)","value":{"stringValue":"9876"}},"ast":"string(\n 9876u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n 9876u~uint\n)~string^uint64_to_string","type":"string"},{"original":{"name":"double","expr":"string(123.456)","value":{"stringValue":"123.456"}},"ast":"string(\n 123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n 123.456~double\n)~string^double_to_string","type":"string"},{"original":{"name":"double_hard","expr":"string(-4.5e-3)","value":{"stringValue":"-0.0045"}},"ast":"string(\n -0.0045^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n -0.0045~double\n)~string^double_to_string","type":"string"},{"original":{"name":"bytes","expr":"string(b'abc')","value":{"stringValue":"abc"}},"ast":"string(\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n b\"abc\"~bytes\n)~string^bytes_to_string","type":"string"},{"original":{"name":"bytes_unicode","expr":"string(b'\\303\\277')","value":{"stringValue":"ÿ"}},"ast":"string(\n b\"ÿ\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n b\"ÿ\"~bytes\n)~string^bytes_to_string","type":"string"},{"original":{"name":"bytes_invalid","expr":"string(b'\\000\\xff')","evalError":{"errors":[{"message":"invalid UTF-8"}]}},"ast":"string(\n b\"\\x00\\xff\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n b\"\\x00\\xff\"~bytes\n)~string^bytes_to_string","type":"string"}]},{"name":"type","tests":[{"original":{"name":"bool","expr":"type(true)","value":{"typeValue":"bool"}},"ast":"type(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n true~bool\n)~type(bool)^type","type":"type(bool)"},{"original":{"name":"bool_denotation","expr":"bool","value":{"typeValue":"bool"}},"ast":"bool^#*expr.Expr_IdentExpr#","checkedAst":"bool~type(bool)^bool","type":"type(bool)"},{"original":{"name":"dyn_no_denotation","expr":"dyn","disableCheck":true,"evalError":{"errors":[{"message":"unknown variable"}]}},"ast":"dyn^#*expr.Expr_IdentExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'dyn' (in container '')\n | dyn\n | ^"},{"original":{"name":"int","expr":"type(0)","value":{"typeValue":"int"}},"ast":"type(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n 0~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"int_denotation","expr":"int","value":{"typeValue":"int"}},"ast":"int^#*expr.Expr_IdentExpr#","checkedAst":"int~type(int)^int","type":"type(int)"},{"original":{"name":"eq_same","expr":"type(true) == type(false)","value":{"boolValue":true}},"ast":"_==_(\n type(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n type(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n true~bool\n )~type(bool)^type,\n type(\n false~bool\n )~type(bool)^type\n)~bool^equals","type":"bool"},{"original":{"name":"uint","expr":"type(64u)","value":{"typeValue":"uint"}},"ast":"type(\n 64u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n 64u~uint\n)~type(uint)^type","type":"type(uint)"},{"original":{"name":"uint_denotation","expr":"uint","value":{"typeValue":"uint"}},"ast":"uint^#*expr.Expr_IdentExpr#","checkedAst":"uint~type(uint)^uint","type":"type(uint)"},{"original":{"name":"double","expr":"type(3.14)","value":{"typeValue":"double"}},"ast":"type(\n 3.14^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n 3.14~double\n)~type(double)^type","type":"type(double)"},{"original":{"name":"double_denotation","expr":"double","value":{"typeValue":"double"}},"ast":"double^#*expr.Expr_IdentExpr#","checkedAst":"double~type(double)^double","type":"type(double)"},{"original":{"name":"null_type","expr":"type(null)","value":{"typeValue":"null_type"}},"ast":"type(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n null~null\n)~type(null)^type","type":"type(null)"},{"original":{"name":"null_type_denotation","expr":"null_type","value":{"typeValue":"null_type"}},"ast":"null_type^#*expr.Expr_IdentExpr#","checkedAst":"null_type~type(null)^null_type","type":"type(null)"},{"original":{"name":"string","expr":"type('foo')","value":{"typeValue":"string"}},"ast":"type(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n \"foo\"~string\n)~type(string)^type","type":"type(string)"},{"original":{"name":"string_denotation","expr":"string","value":{"typeValue":"string"}},"ast":"string^#*expr.Expr_IdentExpr#","checkedAst":"string~type(string)^string","type":"type(string)"},{"original":{"name":"bytes","expr":"type(b'\\xff')","value":{"typeValue":"bytes"}},"ast":"type(\n b\"\\xff\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n b\"\\xff\"~bytes\n)~type(bytes)^type","type":"type(bytes)"},{"original":{"name":"bytes_denotation","expr":"bytes","value":{"typeValue":"bytes"}},"ast":"bytes^#*expr.Expr_IdentExpr#","checkedAst":"bytes~type(bytes)^bytes","type":"type(bytes)"},{"original":{"name":"list","expr":"type([1, 2, 3])","value":{"typeValue":"list"}},"ast":"type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~type(list(int))^type","type":"type(list(int))"},{"original":{"name":"list_denotation","expr":"list","value":{"typeValue":"list"}},"ast":"list^#*expr.Expr_IdentExpr#","checkedAst":"list~type(list(dyn))^list","type":"type(list(dyn))"},{"original":{"name":"lists_monomorphic","expr":"type([1, 2, 3]) == type(['one', 'two', 'three'])","value":{"boolValue":true}},"ast":"_==_(\n type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n [\n \"one\"^#*expr.Constant_StringValue#,\n \"two\"^#*expr.Constant_StringValue#,\n \"three\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n )~type(list(int))^type,\n type(\n [\n \"one\"~string,\n \"two\"~string,\n \"three\"~string\n ]~list(string)\n )~type(list(string))^type\n)~bool^equals","type":"bool"},{"original":{"name":"map","expr":"type({4: 16})","value":{"typeValue":"map"}},"ast":"type(\n {\n 4^#*expr.Constant_Int64Value#:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n {\n 4~int:16~int\n }~map(int, int)\n)~type(map(int, int))^type","type":"type(map(int, int))"},{"original":{"name":"map_denotation","expr":"map","value":{"typeValue":"map"}},"ast":"map^#*expr.Expr_IdentExpr#","checkedAst":"map~type(map(dyn, dyn))^map","type":"type(map(dyn, dyn))"},{"original":{"name":"map_monomorphic","expr":"type({'one': 1}) == type({1: 'one'})","value":{"boolValue":true}},"ast":"_==_(\n type(\n {\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n {\n 1^#*expr.Constant_Int64Value#:\"one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n {\n \"one\"~string:1~int\n }~map(string, int)\n )~type(map(string, int))^type,\n type(\n {\n 1~int:\"one\"~string\n }~map(int, string)\n )~type(map(int, string))^type\n)~bool^equals","type":"bool"},{"original":{"name":"eq_diff","expr":"type(7) == type(7u)","value":{"boolValue":false}},"ast":"_==_(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n 7~int\n )~type(int)^type,\n type(\n 7u~uint\n )~type(uint)^type\n)~bool^equals","type":"bool"},{"original":{"name":"neq_same","expr":"type(0.0) != type(-0.0)","value":{"boolValue":false}},"ast":"_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n -0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n -0~double\n )~type(double)^type\n)~bool^not_equals","type":"bool"},{"original":{"name":"neq_diff","expr":"type(0.0) != type(0)","value":{"boolValue":true}},"ast":"_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n 0~int\n )~type(int)^type\n)~bool^not_equals","type":"bool"},{"original":{"name":"meta","expr":"type(type(7)) == type(type(7u))","value":{"boolValue":true}},"ast":"_==_(\n type(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n type(\n 7~int\n )~type(int)^type\n )~type(type(int))^type,\n type(\n type(\n 7u~uint\n )~type(uint)^type\n )~type(type(uint))^type\n)~bool^equals","type":"bool"},{"original":{"name":"type","expr":"type(int)","value":{"typeValue":"type"}},"ast":"type(\n int^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n int~type(int)^int\n)~type(type(int))^type","type":"type(type(int))"},{"original":{"name":"type_denotation","expr":"type","value":{"typeValue":"type"}},"ast":"type^#*expr.Expr_IdentExpr#","checkedAst":"type~type(type)^type","type":"type(type)"},{"original":{"name":"type_type","expr":"type(type)","value":{"typeValue":"type"}},"ast":"type(\n type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n type~type(type)^type\n)~type(type(type))^type","type":"type(type(type))"}]},{"name":"uint","tests":[{"original":{"name":"int","expr":"uint(1729)","value":{"uint64Value":"1729"}},"ast":"uint(\n 1729^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 1729~int\n)~uint^int64_to_uint64","type":"uint"},{"original":{"name":"int_max","expr":"uint(9223372036854775807)","value":{"uint64Value":"9223372036854775807"}},"ast":"uint(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 9223372036854775807~int\n)~uint^int64_to_uint64","type":"uint"},{"original":{"name":"int_neg","expr":"uint(-1)","evalError":{"errors":[{"message":"range"}]}},"ast":"uint(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n -1~int\n)~uint^int64_to_uint64","type":"uint"},{"original":{"name":"double","expr":"uint(3.14159265)","value":{"uint64Value":"3"}},"ast":"uint(\n 3.14159265^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 3.14159265~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_truncate","expr":"uint(1.9)","value":{"uint64Value":"1"}},"ast":"uint(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 1.9~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_half","expr":"uint(25.5)","value":{"uint64Value":"25"}},"ast":"uint(\n 25.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 25.5~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_big_exact","description":"Beyond exact range (2^53), but no loss of precision (2^55).","expr":"uint(double(36028797018963968u))","value":{"uint64Value":"36028797018963968"}},"ast":"uint(\n double(\n 36028797018963968u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n double(\n 36028797018963968u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_big_precision","description":"Beyond exact range (2^53), but loses precision (2^55 + 1).","expr":"uint(double(36028797018963969u))","value":{"uint64Value":"36028797018963968"}},"ast":"uint(\n double(\n 36028797018963969u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n double(\n 36028797018963969u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"double_uint_max_range","description":"The exact conversion of uint max as a double does not round trip.","expr":"int(18446744073709551615.0)","evalError":{"errors":[{"message":"range"}]}},"ast":"int(\n 1.8446744073709552e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1.8446744073709552e+19~double\n)~int^double_to_int64","type":"int"},{"original":{"name":"double_range_beyond_uint","expr":"uint(6.022e23)","evalError":{"errors":[{"message":"range"}]}},"ast":"uint(\n 6.022e+23^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 6.022e+23~double\n)~uint^double_to_uint64","type":"uint"},{"original":{"name":"string","expr":"uint('300')","value":{"uint64Value":"300"}},"ast":"uint(\n \"300\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n \"300\"~string\n)~uint^string_to_uint64","type":"uint"}]},{"name":"bool","tests":[{"original":{"name":"string_1","expr":"bool('1')","value":{"boolValue":true}},"ast":"bool(\n \"1\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"1\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_t","expr":"bool('t')","value":{"boolValue":true}},"ast":"bool(\n \"t\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"t\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_lowercase","expr":"bool('true')","value":{"boolValue":true}},"ast":"bool(\n \"true\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"true\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_uppercase","expr":"bool('TRUE')","value":{"boolValue":true}},"ast":"bool(\n \"TRUE\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"TRUE\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_pascalcase","expr":"bool('True')","value":{"boolValue":true}},"ast":"bool(\n \"True\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"True\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_0","expr":"bool('0')","value":{"boolValue":false}},"ast":"bool(\n \"0\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"0\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_f","expr":"bool('f')","value":{"boolValue":false}},"ast":"bool(\n \"f\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"f\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_lowercase","expr":"bool('false')","value":{"boolValue":false}},"ast":"bool(\n \"false\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"false\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_uppercase","expr":"bool('FALSE')","value":{"boolValue":false}},"ast":"bool(\n \"FALSE\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"FALSE\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_pascalcase","expr":"bool('False')","value":{"boolValue":false}},"ast":"bool(\n \"False\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"False\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_true_badcase","expr":"bool('TrUe')","evalError":{"errors":[{"message":"Type conversion error"}]}},"ast":"bool(\n \"TrUe\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"TrUe\"~string\n)~bool^string_to_bool","type":"bool"},{"original":{"name":"string_false_badcase","expr":"bool('FaLsE')","evalError":{"errors":[{"message":"Type conversion error"}]}},"ast":"bool(\n \"FaLsE\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n \"FaLsE\"~string\n)~bool^string_to_bool","type":"bool"}]},{"name":"identity","tests":[{"original":{"name":"bool","expr":"bool(true)","value":{"boolValue":true}},"ast":"bool(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bool(\n true~bool\n)~bool^bool_to_bool","type":"bool"},{"original":{"name":"int","expr":"int(1)","value":{"int64Value":"1"}},"ast":"int(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n 1~int\n)~int^int64_to_int64","type":"int"},{"original":{"name":"uint","expr":"uint(1u)","value":{"uint64Value":"1"}},"ast":"uint(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"uint(\n 1u~uint\n)~uint^uint64_to_uint64","type":"uint"},{"original":{"name":"double","expr":"double(5.5)","value":{"doubleValue":5.5}},"ast":"double(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"double(\n 5.5~double\n)~double^double_to_double","type":"double"},{"original":{"name":"string","expr":"string('hello')","value":{"stringValue":"hello"}},"ast":"string(\n \"hello\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n \"hello\"~string\n)~string^string_to_string","type":"string"},{"original":{"name":"bytes","expr":"bytes(b'abc')","value":{"bytesValue":"YWJj"}},"ast":"bytes(\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"bytes(\n b\"abc\"~bytes\n)~bytes^bytes_to_bytes","type":"bytes"},{"original":{"name":"duration","expr":"duration(duration('100s')) == duration('100s')","value":{"boolValue":true}},"ast":"_==_(\n duration(\n duration(\n \"100s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"100s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n duration(\n duration(\n \"100s\"~string\n )~duration^string_to_duration\n )~duration^duration_to_duration,\n duration(\n \"100s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"timestamp","expr":"timestamp(timestamp(1000000000)) == timestamp(1000000000)","value":{"boolValue":true}},"ast":"_==_(\n timestamp(\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n timestamp(\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n )~timestamp^timestamp_to_timestamp,\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n)~bool^equals","type":"bool"}]}]},{"name":"dynamic","suites":[{"name":"int32","tests":[{"original":{"name":"literal","expr":"google.protobuf.Int32Value{value: -123}","value":{"int64Value":"-123"}},"ast":"google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int32Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int32Value","type":"wrapper(int)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Int32Value{value: -123}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int32Value{value: -123}.value\n | .......................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.Int32Value{}","value":{"int64Value":"0"}},"ast":"google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value","type":"wrapper(int)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Int32Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Int32Value","value":2000000}}}},"value":{"int64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(int)^x","type":"wrapper(int)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_int32_wrapper: 432}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":432}}},"ast":"TestAllTypes{\n single_int32_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_int32_wrapper: 0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":0}}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_max","expr":"TestAllTypes{single_int32_wrapper: 2147483647}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":2147483647}}},"ast":"TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_min","expr":"TestAllTypes{single_int32_wrapper: -2147483648}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":-2147483648}}},"ast":"TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","expr":"TestAllTypes{single_int32_wrapper: 12345678900}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_int32_wrapper:12345678900^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:12345678900~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"int64Value":"642"}},"ast":"TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_int32_wrapper: -975}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":-975}}},"ast":"TestAllTypes{\n single_int32_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_int32_wrapper: 0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":0}}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_max","expr":"TestAllTypes{single_int32_wrapper: 2147483647}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":2147483647}}},"ast":"TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_min","expr":"TestAllTypes{single_int32_wrapper: -2147483648}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":-2147483648}}},"ast":"TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","expr":"TestAllTypes{single_int32_wrapper: -998877665544332211}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_int32_wrapper:-998877665544332211^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-998877665544332211~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper","container":"cel.expr.conformance.proto3","value":{"int64Value":"642"}},"ast":"TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_int32_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"}]},{"name":"int64","tests":[{"original":{"name":"literal","expr":"google.protobuf.Int64Value{value: -123}","value":{"int64Value":"-123"}},"ast":"google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int64Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int64Value","type":"wrapper(int)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Int64Value{value: -123}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int64Value{value: -123}.value\n | .......................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.Int64Value{}","value":{"int64Value":"0"}},"ast":"google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value","type":"wrapper(int)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Int64Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Int64Value","value":"2000000"}}}},"value":{"int64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(int)^x","type":"wrapper(int)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_int64_wrapper: 432}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64Wrapper":"432"}}},"ast":"TestAllTypes{\n single_int64_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_int64_wrapper: 0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_int64_wrapper: -975}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64Wrapper":"-975"}}},"ast":"TestAllTypes{\n single_int64_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_int64_wrapper: 0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"uint32","tests":[{"original":{"name":"literal","expr":"google.protobuf.UInt32Value{value: 123u}","value":{"uint64Value":"123"}},"ast":"google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt32Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt32Value","type":"wrapper(uint)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.UInt32Value{value: 123u}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt32Value{value: 123u}.value\n | ........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.UInt32Value{}","value":{"uint64Value":"0"}},"ast":"google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value","type":"wrapper(uint)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.UInt32Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.UInt32Value","value":2000000}}}},"value":{"uint64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(uint)^x","type":"wrapper(uint)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_uint32_wrapper: 432u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":432}}},"ast":"TestAllTypes{\n single_uint32_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_uint32_wrapper: 0u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":0}}},"ast":"TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_max","expr":"TestAllTypes{single_uint32_wrapper: 4294967295u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":4294967295}}},"ast":"TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","expr":"TestAllTypes{single_uint32_wrapper: 6111222333u}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_uint32_wrapper: 975u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":975}}},"ast":"TestAllTypes{\n single_uint32_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_uint32_wrapper: 0u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":0}}},"ast":"TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_max","expr":"TestAllTypes{single_uint32_wrapper: 4294967295u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":4294967295}}},"ast":"TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","expr":"TestAllTypes{single_uint32_wrapper: 6111222333u}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range error"}]}},"ast":"TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_uint32_wrapper: 258u}.single_uint32_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"258"}},"ast":"TestAllTypes{\n single_uint32_wrapper:258u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:258u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_uint32_wrapper: 0u}.single_uint32_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"0"}},"ast":"TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_uint32_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)","type":"wrapper(uint)"}]},{"name":"uint64","tests":[{"original":{"name":"literal","expr":"google.protobuf.UInt64Value{value: 123u}","value":{"uint64Value":"123"}},"ast":"google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt64Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt64Value","type":"wrapper(uint)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.UInt64Value{value: 123u}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt64Value{value: 123u}.value\n | ........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.UInt64Value{}","value":{"uint64Value":"0"}},"ast":"google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value","type":"wrapper(uint)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.UInt64Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.UInt64Value","value":"2000000"}}}},"value":{"uint64Value":"2000000"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(uint)^x","type":"wrapper(uint)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_uint64_wrapper: 432u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64Wrapper":"432"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_uint64_wrapper: 0u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_uint64_wrapper: 975u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64Wrapper":"975"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_uint64_wrapper: 0u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64Wrapper":"0"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_uint64_wrapper: 5123123123u}.single_uint64_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"5123123123"}},"ast":"TestAllTypes{\n single_uint64_wrapper:5123123123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:5123123123u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_uint64_wrapper: 0u}.single_uint64_wrapper","container":"cel.expr.conformance.proto2","value":{"uint64Value":"0"}},"ast":"TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)","type":"wrapper(uint)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_uint64_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)","type":"wrapper(uint)"}]},{"name":"float","tests":[{"original":{"name":"literal","expr":"google.protobuf.FloatValue{value: -1.5e3}","value":{"doubleValue":-1500}},"ast":"google.protobuf.FloatValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.FloatValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.FloatValue","type":"wrapper(double)"},{"original":{"name":"literal_not_double","description":"Use a number with no exact representation to make sure we actually narrow to a float.","expr":"google.protobuf.FloatValue{value: 1.333} == 1.333","value":{"boolValue":false}},"ast":"_==_(\n google.protobuf.FloatValue{\n value:1.333^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1.333^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:1.333~double\n }~wrapper(double)^google.protobuf.FloatValue,\n 1.333~double\n)~bool^equals","type":"bool"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.FloatValue{value: 3.1416}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.FloatValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:42: type 'wrapper(double)' does not support field selection\n | google.protobuf.FloatValue{value: 3.1416}.value\n | .........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.FloatValue{}","value":{"doubleValue":0}},"ast":"google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue","type":"wrapper(double)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.FloatValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.FloatValue","value":-1250000}}}},"value":{"doubleValue":-1250000}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(double)^x","type":"wrapper(double)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_float_wrapper: 86.75}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":86.75}}},"ast":"TestAllTypes{\n single_float_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_subnorm","description":"Subnormal single floats range from ~1e-38 to ~1e-45.","expr":"TestAllTypes{single_float_wrapper: 1e-40}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":1e-40}}},"ast":"TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_round_to_zero","description":"Subnormal single floats range from ~1e-38 to ~1e-45.","expr":"TestAllTypes{single_float_wrapper: 1e-50}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:1e-50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-50~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","description":"Single float max is about 3.4e38","expr":"TestAllTypes{single_float_wrapper: 1.4e55}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":"Infinity"}}},"ast":"TestAllTypes{\n single_float_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_float_wrapper: -12.375}.single_float_wrapper","container":"cel.expr.conformance.proto2","value":{"doubleValue":-12.375}},"ast":"TestAllTypes{\n single_float_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper","container":"cel.expr.conformance.proto2","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_float_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_float_wrapper: -9.75}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":-9.75}}},"ast":"TestAllTypes{\n single_float_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto2_subnorm","description":"Subnormal single floats range from ~1e-38 to ~1e-45.","expr":"TestAllTypes{single_float_wrapper: 1e-40}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":1e-40}}},"ast":"TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3_round_to_zero","expr":"TestAllTypes{single_float_wrapper: -9.9e-100}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":0}}},"ast":"TestAllTypes{\n single_float_wrapper:-9.9e-100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e-100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","description":"Single float min is about -3.4e38","expr":"TestAllTypes{single_float_wrapper: -9.9e100}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":"-Infinity"}}},"ast":"TestAllTypes{\n single_float_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_float_wrapper: 64.25}.single_float_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":64.25}},"ast":"TestAllTypes{\n single_float_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_float_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)","type":"wrapper(double)"}]},{"name":"double","tests":[{"original":{"name":"literal","expr":"google.protobuf.DoubleValue{value: -1.5e3}","value":{"doubleValue":-1500}},"ast":"google.protobuf.DoubleValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.DoubleValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.DoubleValue","type":"wrapper(double)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.DoubleValue{value: 3.1416}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.DoubleValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:43: type 'wrapper(double)' does not support field selection\n | google.protobuf.DoubleValue{value: 3.1416}.value\n | ..........................................^"},{"original":{"name":"literal_zero","expr":"google.protobuf.DoubleValue{}","value":{"doubleValue":0}},"ast":"google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue","type":"wrapper(double)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.DoubleValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.DoubleValue","value":-1250000}}}},"value":{"doubleValue":-1250000}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(double)^x","type":"wrapper(double)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_double_wrapper: 86.75}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":86.75}}},"ast":"TestAllTypes{\n single_double_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_double_wrapper: 0.0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":0}}},"ast":"TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_range","expr":"TestAllTypes{single_double_wrapper: 1.4e55}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":1.4e+55}}},"ast":"TestAllTypes{\n single_double_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_double_wrapper: -12.375}.single_double_wrapper","container":"cel.expr.conformance.proto2","value":{"doubleValue":-12.375}},"ast":"TestAllTypes{\n single_double_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_double_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_double_wrapper: -9.75}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":-9.75}}},"ast":"TestAllTypes{\n single_double_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_double_wrapper: 0.0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":0}}},"ast":"TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_range","expr":"TestAllTypes{single_double_wrapper: -9.9e100}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":-9.9e+100}}},"ast":"TestAllTypes{\n single_double_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_double_wrapper: 64.25}.single_double_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":64.25}},"ast":"TestAllTypes{\n single_double_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_double_wrapper: 0.0}.single_double_wrapper","container":"cel.expr.conformance.proto3","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_double_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)","type":"wrapper(double)"}]},{"name":"bool","tests":[{"original":{"name":"literal","expr":"google.protobuf.BoolValue{value: true}","value":{"boolValue":true}},"ast":"google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BoolValue{\n value:true~bool\n}~wrapper(bool)^google.protobuf.BoolValue","type":"wrapper(bool)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.BoolValue{value: true}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:39: type 'wrapper(bool)' does not support field selection\n | google.protobuf.BoolValue{value: true}.value\n | ......................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.BoolValue{}","value":{"boolValue":false}},"ast":"google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue","type":"wrapper(bool)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.BoolValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.BoolValue","value":true}}}},"value":{"boolValue":true}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(bool)^x","type":"wrapper(bool)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_false","expr":"TestAllTypes{single_bool_wrapper: false}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBoolWrapper":false}}},"ast":"TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_false","expr":"TestAllTypes{single_bool_wrapper: false}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBoolWrapper":false}}},"ast":"TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"string","tests":[{"original":{"name":"literal","expr":"google.protobuf.StringValue{value: 'foo'}","value":{"stringValue":"foo"}},"ast":"google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.StringValue{\n value:\"foo\"~string\n}~wrapper(string)^google.protobuf.StringValue","type":"wrapper(string)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.StringValue{value: 'foo'}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:42: type 'wrapper(string)' does not support field selection\n | google.protobuf.StringValue{value: 'foo'}.value\n | .........................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.StringValue{}","value":{"stringValue":""}},"ast":"google.protobuf.StringValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue","type":"wrapper(string)"},{"original":{"name":"literal_unicode","expr":"google.protobuf.StringValue{value: 'flambé'}","value":{"stringValue":"flambé"}},"ast":"google.protobuf.StringValue{\n value:\"flambé\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.StringValue{\n value:\"flambé\"~string\n}~wrapper(string)^google.protobuf.StringValue","type":"wrapper(string)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.StringValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.StringValue","value":"bar"}}}},"value":{"stringValue":"bar"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(string)^x","type":"wrapper(string)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_string_wrapper: 'baz'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStringWrapper":"baz"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"baz\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:\"baz\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_string_wrapper: ''}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStringWrapper":""}}},"ast":"TestAllTypes{\n single_string_wrapper:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:\"\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_string_wrapper: 'bletch'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStringWrapper":"bletch"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"bletch\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:\"bletch\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_string_wrapper: ''}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStringWrapper":""}}},"ast":"TestAllTypes{\n single_string_wrapper:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:\"\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"bytes","tests":[{"original":{"name":"literal","expr":"google.protobuf.BytesValue{value: b'foo\\123'}","value":{"bytesValue":"Zm9vUw=="}},"ast":"google.protobuf.BytesValue{\n value:b\"fooS\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BytesValue{\n value:b\"fooS\"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue","type":"wrapper(bytes)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.BytesValue{value: b'foo'}.value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.BytesValue{\n value:b\"foo\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:42: type 'wrapper(bytes)' does not support field selection\n | google.protobuf.BytesValue{value: b'foo'}.value\n | .........................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.BytesValue{}","value":{"bytesValue":""}},"ast":"google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue","type":"wrapper(bytes)"},{"original":{"name":"literal_unicode","expr":"google.protobuf.BytesValue{value: b'flambé'}","value":{"bytesValue":"ZmxhbWLDqQ=="}},"ast":"google.protobuf.BytesValue{\n value:b\"flambé\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.BytesValue{\n value:b\"flambé\"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue","type":"wrapper(bytes)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.BytesValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.BytesValue","value":"YmFy"}}}},"value":{"bytesValue":"YmFy"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~wrapper(bytes)^x","type":"wrapper(bytes)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_bytes_wrapper: b'baz'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytesWrapper":"YmF6"}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"baz\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b\"baz\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_bytes_wrapper: b''}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytesWrapper":""}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b\"\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_bytes_wrapper: b'bletch'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytesWrapper":"YmxldGNo"}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"bletch\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b\"bletch\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_bytes_wrapper: b''}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytesWrapper":""}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b\"\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"list","tests":[{"original":{"name":"literal","expr":"google.protobuf.ListValue{values: [3.0, 'foo', null]}","value":{"listValue":{"values":[{"doubleValue":3},{"stringValue":"foo"},{"nullValue":null}]}}},"ast":"google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.ListValue{\n values:[\n 3~double,\n \"foo\"~string,\n null~null\n ]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue","type":"list(dyn)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.ListValue{values: [3.0, 'foo', null]}.values","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.values^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:54: type 'list(dyn)' does not support field selection\n | google.protobuf.ListValue{values: [3.0, 'foo', null]}.values\n | .....................................................^"},{"original":{"name":"literal_empty","expr":"google.protobuf.ListValue{values: []}","value":{"listValue":{}}},"ast":"google.protobuf.ListValue{\n values:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.ListValue{\n values:[]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue","type":"list(dyn)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.ListValue"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.ListValue","value":["bar",["a","b"]]}}}},"value":{"listValue":{"values":[{"stringValue":"bar"},{"listValue":{"values":[{"stringValue":"a"},{"stringValue":"b"}]}}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~list(dyn)^x","type":"list(dyn)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{list_value: [1.0, 'one']}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","listValue":[1,"one"]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{list_value: []}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","listValue":[]}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{list_value: [1.0, 'one']}.list_value","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"doubleValue":1},{"stringValue":"one"}]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{list_value: []}.list_value","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto2_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.list_value","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{list_value: [1.0, 'one']}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","listValue":[1,"one"]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{list_value: []}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","listValue":[]}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{list_value: [1.0, 'one']}.list_value","container":"cel.expr.conformance.proto3","value":{"listValue":{"values":[{"doubleValue":1},{"stringValue":"one"}]}}},"ast":"TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n \"one\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n \"one\"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{list_value: []}.list_value","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"},{"original":{"name":"field_read_proto3_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.list_value","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)","type":"list(dyn)"}]},{"name":"struct","tests":[{"original":{"name":"literal","expr":"google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}","value":{"mapValue":{"entries":[{"key":{"stringValue":"uno"},"value":{"doubleValue":1}},{"key":{"stringValue":"dos"},"value":{"doubleValue":2}}]}}},"ast":"google.protobuf.Struct{\n fields:{\n \"uno\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"dos\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Struct{\n fields:{\n \"uno\"~string:1~double,\n \"dos\"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct","type":"map(string, dyn)"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}.fields","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Struct{\n fields:{\n \"uno\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"dos\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.fields^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Struct{\n fields:{\n \"uno\"~string:1~double,\n \"dos\"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct.fields~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Struct{fields: {}}","value":{"mapValue":{}}},"ast":"google.protobuf.Struct{\n fields:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Struct{\n fields:{}~map(string, dyn)\n}~map(string, dyn)^google.protobuf.Struct","type":"map(string, dyn)"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Struct"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Struct","value":{"first":"Abraham","last":"Lincoln"}}}}},"value":{"mapValue":{"entries":[{"key":{"stringValue":"first"},"value":{"stringValue":"Abraham"}},{"key":{"stringValue":"last"},"value":{"stringValue":"Lincoln"}}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~map(string, dyn)^x","type":"map(string, dyn)"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStruct":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_struct:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_struct: {}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStruct":{}}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_bad","expr":"TestAllTypes{single_struct: {1: 'uno'}}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"bad key type"}]}},"ast":"TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_struct: {'one': 1.0}}.single_struct","container":"cel.expr.conformance.proto2","value":{"mapValue":{"entries":[{"key":{"stringValue":"one"},"value":{"doubleValue":1}}]}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n \"one\"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{single_struct: {}}.single_struct","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto2_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.single_struct","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStruct":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_struct:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_struct: {}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStruct":{}}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_bad","expr":"TestAllTypes{single_struct: {1: 'uno'}}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"bad key type"}]}},"ast":"TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_struct: {'one': 1.0}}.single_struct","container":"cel.expr.conformance.proto3","value":{"mapValue":{"entries":[{"key":{"stringValue":"one"},"value":{"doubleValue":1}}]}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n \"one\"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{single_struct: {}}.single_struct","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"},{"original":{"name":"field_read_proto3_unset","description":"Not a wrapper type, so doesn't convert to null.","expr":"TestAllTypes{}.single_struct","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)","type":"map(string, dyn)"}]},{"name":"value_null","tests":[{"original":{"name":"literal","expr":"Value{null_value: NullValue.NULL_VALUE}","container":"google.protobuf","value":{"nullValue":null}},"ast":"Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"Value{null_value: NullValue.NULL_VALUE}.null_value","disableCheck":true,"container":"google.protobuf","evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.null_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value.null_value~dyn","type":"dyn"},{"original":{"name":"literal_unset","expr":"google.protobuf.Value{}","value":{"nullValue":null}},"ast":"google.protobuf.Value{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":null}}}},"value":{"nullValue":null}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: null}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":null}}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_unset","expr":"TestAllTypes{}.single_value","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: null}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":null}}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_unset","expr":"TestAllTypes{}.single_value","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_number","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{number_value: 12.5}","value":{"doubleValue":12.5}},"ast":"google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{number_value: 12.5}.number_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.number_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value.number_value~dyn","type":"dyn"},{"original":{"name":"literal_zero","expr":"google.protobuf.Value{number_value: 0.0}","value":{"doubleValue":0}},"ast":"google.protobuf.Value{\n number_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n number_value:0~double\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":-26.375}}}},"value":{"doubleValue":-26.375}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: 7e23}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":7e+23}}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_zero","expr":"TestAllTypes{single_value: 0.0}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":0}}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: 7e23}.single_value","container":"cel.expr.conformance.proto2","value":{"doubleValue":7e+23}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_value: 0.0}.single_value","container":"cel.expr.conformance.proto2","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: 7e23}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":7e+23}}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_zero","expr":"TestAllTypes{single_value: 0.0}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":0}}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: 7e23}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":7e+23}},"ast":"TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_value: 0.0}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":0}},"ast":"TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_string","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{string_value: 'foo'}","value":{"stringValue":"foo"}},"ast":"google.protobuf.Value{\n string_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n string_value:\"foo\"~string\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{string_value: 'foo'}.string_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n string_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.string_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n string_value:\"foo\"~string\n}~dyn^google.protobuf.Value.string_value~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Value{string_value: ''}","value":{"stringValue":""}},"ast":"google.protobuf.Value{\n string_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n string_value:\"\"~string\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":"bar"}}}},"value":{"stringValue":"bar"}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: 'baz'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":"baz"}}},"ast":"TestAllTypes{\n single_value:\"baz\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"baz\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_value: ''}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":""}}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: 'bletch'}.single_value","container":"cel.expr.conformance.proto2","value":{"stringValue":"bletch"}},"ast":"TestAllTypes{\n single_value:\"bletch\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"bletch\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_zero","expr":"TestAllTypes{single_value: ''}.single_value","container":"cel.expr.conformance.proto2","value":{"stringValue":""}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: 'baz'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":"baz"}}},"ast":"TestAllTypes{\n single_value:\"baz\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"baz\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_value: ''}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":""}}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: 'bletch'}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"bletch"}},"ast":"TestAllTypes{\n single_value:\"bletch\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"bletch\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_zero","expr":"TestAllTypes{single_value: ''}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":""}},"ast":"TestAllTypes{\n single_value:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_bool","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{bool_value: true}","value":{"boolValue":true}},"ast":"google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{bool_value: true}.bool_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.bool_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value.bool_value~dyn","type":"dyn"},{"original":{"name":"literal_false","expr":"google.protobuf.Value{bool_value: false}","value":{"boolValue":false}},"ast":"google.protobuf.Value{\n bool_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n bool_value:false~bool\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":true}}}},"value":{"boolValue":true}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":true}}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_false","expr":"TestAllTypes{single_value: false}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":false}}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: true}.single_value","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_false","expr":"TestAllTypes{single_value: false}.single_value","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":true}}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_false","expr":"TestAllTypes{single_value: false}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":false}}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: true}.single_value","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_false","expr":"TestAllTypes{single_value: false}.single_value","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_struct","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}","value":{"mapValue":{"entries":[{"key":{"stringValue":"a"},"value":{"doubleValue":1}},{"key":{"stringValue":"b"},"value":{"stringValue":"two"}}]}}},"ast":"google.protobuf.Value{\n struct_value:{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n struct_value:{\n \"a\"~string:1~double,\n \"b\"~string:\"two\"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}.struct_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n struct_value:{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.struct_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n struct_value:{\n \"a\"~string:1~double,\n \"b\"~string:\"two\"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value.struct_value~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Value{struct_value: {}}","value":{"mapValue":{}}},"ast":"google.protobuf.Value{\n struct_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n struct_value:{}~map(string, dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":{"x":null,"y":false}}}}},"value":{"mapValue":{"entries":[{"key":{"stringValue":"x"},"value":{"nullValue":null}},{"key":{"stringValue":"y"},"value":{"boolValue":false}}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_value:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_value: {}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":{}}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: {'i': true}}.single_value","container":"cel.expr.conformance.proto2","value":{"mapValue":{"entries":[{"key":{"stringValue":"i"},"value":{"boolValue":true}}]}}},"ast":"TestAllTypes{\n single_value:{\n \"i\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n \"i\"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{single_value: {}}.single_value","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":{"deux":2,"un":1}}}},"ast":"TestAllTypes{\n single_value:{\n \"un\"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n \"deux\"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n \"un\"~string:1~double,\n \"deux\"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_value: {}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":{}}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: {'i': true}}.single_value","container":"cel.expr.conformance.proto3","value":{"mapValue":{"entries":[{"key":{"stringValue":"i"},"value":{"boolValue":true}}]}}},"ast":"TestAllTypes{\n single_value:{\n \"i\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n \"i\"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{single_value: {}}.single_value","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"value_list","tests":[{"original":{"name":"literal","expr":"google.protobuf.Value{list_value: ['a', 3.0]}","value":{"listValue":{"values":[{"stringValue":"a"},{"doubleValue":3}]}}},"ast":"google.protobuf.Value{\n list_value:[\n \"a\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n list_value:[\n \"a\"~string,\n 3~double\n ]~list(dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Value{list_value: []}.list_value","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value.list_value~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Value{list_value: []}","value":{"listValue":{}}},"ast":"google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value","type":"dyn"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Value"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Value","value":[1,true,"hi"]}}}},"value":{"listValue":{"values":[{"doubleValue":1},{"boolValue":true},{"stringValue":"hi"}]}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~dyn^x","type":"dyn"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_value: ['un', 1.0]}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":["un",1]}}},"ast":"TestAllTypes{\n single_value:[\n \"un\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n \"un\"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_assign_proto2_empty","expr":"TestAllTypes{single_value: []}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":[]}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_value: ['i', true]}.single_value","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"i"},{"boolValue":true}]}}},"ast":"TestAllTypes{\n single_value:[\n \"i\"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n \"i\"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto2_empty","expr":"TestAllTypes{single_value: []}.single_value","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_value: ['un', 1.0]}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":["un",1]}}},"ast":"TestAllTypes{\n single_value:[\n \"un\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n \"un\"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_assign_proto3_empty","expr":"TestAllTypes{single_value: []}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":[]}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_value: ['i', true]}.single_value","container":"cel.expr.conformance.proto3","value":{"listValue":{"values":[{"stringValue":"i"},{"boolValue":true}]}}},"ast":"TestAllTypes{\n single_value:[\n \"i\"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n \"i\"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"field_read_proto3_empty","expr":"TestAllTypes{single_value: []}.single_value","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"any","tests":[{"original":{"name":"literal","expr":"google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}},"ast":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\b\\x96\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\b\\x96\\x01\"~bytes\n}~any^google.protobuf.Any","type":"any"},{"original":{"name":"literal_no_field_access","expr":"google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}.type_url","disableCheck":true,"evalError":{"errors":[{"message":"no_matching_overload"}]}},"ast":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b\"\\b\\x96\\x01\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.type_url^#*expr.Expr_SelectExpr#","checkedAst":"google.protobuf.Any{\n type_url:\"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes\"~string,\n value:b\"\\b\\x96\\x01\"~bytes\n}~any^google.protobuf.Any.type_url~dyn","type":"dyn"},{"original":{"name":"literal_empty","expr":"google.protobuf.Any{}","evalError":{"errors":[{"message":"conversion"}]}},"ast":"google.protobuf.Any{}^#*expr.Expr_StructExpr#","checkedAst":"google.protobuf.Any{}~any^google.protobuf.Any","type":"any"},{"original":{"name":"var","expr":"x","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Any"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Any","value":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}}}},"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}},"ast":"x^#*expr.Expr_IdentExpr#","checkedAst":"x~any^x","type":"any"},{"original":{"name":"field_assign_proto2","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"field_read_proto2","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":150}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"field_assign_proto3","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":150}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"field_read_proto3","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":150}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"complex","tests":[{"original":{"name":"any_list_map","expr":"TestAllTypes{single_any: [{'almost': 'done'}]}.single_any","container":"cel.expr.conformance.proto3","value":{"listValue":{"values":[{"mapValue":{"entries":[{"key":{"stringValue":"almost"},"value":{"stringValue":"done"}}]}}]}}},"ast":"TestAllTypes{\n single_any:[\n {\n \"almost\"^#*expr.Constant_StringValue#:\"done\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:[\n {\n \"almost\"~string:\"done\"~string\n }~map(string, string)\n ]~list(map(string, string))\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]}]},{"name":"encoders_ext","suites":[{"name":"encode","tests":[{"original":{"name":"hello","expr":"base64.encode(b'hello')","value":{"stringValue":"aGVsbG8="}},"ast":"base64^#*expr.Expr_IdentExpr#.encode(\n b\"hello\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.encode(\n b\"hello\"~bytes\n)~string^base64_encode_bytes","type":"string"}]},{"name":"decode","tests":[{"original":{"name":"hello","expr":"base64.decode('aGVsbG8=')","value":{"bytesValue":"aGVsbG8="}},"ast":"base64^#*expr.Expr_IdentExpr#.decode(\n \"aGVsbG8=\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.decode(\n \"aGVsbG8=\"~string\n)~bytes^base64_decode_string","type":"bytes"},{"original":{"name":"hello_without_padding","expr":"base64.decode('aGVsbG8')","value":{"bytesValue":"aGVsbG8="}},"ast":"base64^#*expr.Expr_IdentExpr#.decode(\n \"aGVsbG8\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.decode(\n \"aGVsbG8\"~string\n)~bytes^base64_decode_string","type":"bytes"}]},{"name":"round_trip","tests":[{"original":{"name":"hello","expr":"base64.decode(base64.encode(b'Hello World!'))","value":{"bytesValue":"SGVsbG8gV29ybGQh"}},"ast":"base64^#*expr.Expr_IdentExpr#.decode(\n base64^#*expr.Expr_IdentExpr#.encode(\n b\"Hello World!\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"base64.decode(\n base64.encode(\n b\"Hello World!\"~bytes\n )~string^base64_encode_bytes\n)~bytes^base64_decode_string","type":"bytes"}]}]},{"name":"enums","suites":[{"name":"legacy_proto2","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto2","value":{"int64Value":"2"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto2","value":{"int64Value":"1"}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison","expr":"GlobalEnum.GAR == 1","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"arithmetic","expr":"TestAllTypes.NestedEnum.BAR + 3","container":"cel.expr.conformance.proto2","value":{"int64Value":"4"}},"ast":"_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64","type":"int"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto2","value":{"typeValue":"int"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto2","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: 1}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_big","expr":"TestAllTypes{standalone_enum: 5000000000}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_neg","expr":"TestAllTypes{standalone_enum: -7000000000}","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"access_repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"assign_repeated_enum","expr":"TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","repeatedNestedEnum":["FOO","BAR"]}}},"ast":"TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"list_enum_as_list_int","expr":"0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"enum_as_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list","type":"bool"}]},{"name":"legacy_proto3","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto3","value":{"int64Value":"2"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto3","value":{"int64Value":"1"}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison","expr":"GlobalEnum.GAR == 1","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"arithmetic","expr":"TestAllTypes.NestedEnum.BAR + 3","container":"cel.expr.conformance.proto3","value":{"int64Value":"4"}},"ast":"_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64","type":"int"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto3","value":{"typeValue":"int"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto3","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"select","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}}},"value":{"int64Value":"2"}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_big","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":108}}}},"value":{"int64Value":"108"}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_neg","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-3}}}},"value":{"int64Value":"-3"}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"typeValue":"int"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: 1}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_big","expr":"TestAllTypes{standalone_enum: 99}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":99}}},"ast":"TestAllTypes{\n standalone_enum:99^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:99~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_neg","expr":"TestAllTypes{standalone_enum: -1}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-1}}},"ast":"TestAllTypes{\n standalone_enum:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_big","expr":"TestAllTypes{standalone_enum: 5000000000}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int_too_neg","expr":"TestAllTypes{standalone_enum: -7000000000}","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"access_repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"assign_repeated_enum","expr":"TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","repeatedNestedEnum":["FOO","BAR"]}}},"ast":"TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"list_enum_as_list_int","expr":"0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"enum_as_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list","type":"bool"}]},{"name":"strong_proto2","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum","value":2}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":1}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum"}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison_true","expr":"GlobalEnum.GAR == GlobalEnum.GAR","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR\n)~bool^equals","type":"bool"},{"original":{"name":"comparison_false","expr":"GlobalEnum.GAR == GlobalEnum.GAZ","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~bool^equals","type":"bool"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto2","value":{"typeValue":"cel.expr.conformance.proto2.GlobalEnum"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto2","value":{"typeValue":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"typeValue":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^"},{"original":{"name":"convert_symbol_to_int","expr":"int(GlobalEnum.GAZ)","container":"cel.expr.conformance.proto2","value":{"int64Value":"2"}},"ast":"int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~int^int64_to_int64","type":"int"},{"original":{"name":"convert_unnamed_to_int","description":"Disable check - missing way to declare enums.","expr":"int(x)","disableCheck":true,"bindings":{"x":{"value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum","value":444}}}},"value":{"int64Value":"444"}},"ast":"int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^"},{"original":{"name":"convert_int_inrange","expr":"TestAllTypes.NestedEnum(2)","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(2)\n | .......................^"},{"original":{"name":"convert_int_big","expr":"TestAllTypes.NestedEnum(20000)","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":20000}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(20000)\n | .......................^"},{"original":{"name":"convert_int_neg","expr":"GlobalEnum(-33)","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.GlobalEnum","value":-33}}},"ast":"GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto2')\n | GlobalEnum(-33)\n | ..........^"},{"original":{"name":"convert_int_too_big","expr":"TestAllTypes.NestedEnum(5000000000)","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^"},{"original":{"name":"convert_int_too_neg","expr":"TestAllTypes.NestedEnum(-7000000000)","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^"},{"original":{"name":"convert_string","expr":"TestAllTypes.NestedEnum('BAZ')","container":"cel.expr.conformance.proto2","value":{"enumValue":{"type":"cel.expr.conformance.proto2.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BAZ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^"},{"original":{"name":"convert_string_bad","expr":"TestAllTypes.NestedEnum('BLETCH')","container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"invalid"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BLETCH\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^"}]},{"name":"strong_proto3","tests":[{"original":{"name":"literal_global","expr":"GlobalEnum.GAZ","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum","value":2}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ","type":"int"},{"original":{"name":"literal_nested","expr":"TestAllTypes.NestedEnum.BAR","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":1}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR","type":"int"},{"original":{"name":"literal_zero","expr":"GlobalEnum.GOO","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum"}}},"ast":"GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO","type":"int"},{"original":{"name":"comparison_true","expr":"GlobalEnum.GAR == GlobalEnum.GAR","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR\n)~bool^equals","type":"bool"},{"original":{"name":"comparison_false","expr":"GlobalEnum.GAR == GlobalEnum.GAZ","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~bool^equals","type":"bool"},{"original":{"name":"type_global","expr":"type(GlobalEnum.GOO)","container":"cel.expr.conformance.proto3","value":{"typeValue":"cel.expr.conformance.proto3.GlobalEnum"}},"ast":"type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type","type":"type(int)"},{"original":{"name":"type_nested","expr":"type(TestAllTypes.NestedEnum.BAZ)","container":"cel.expr.conformance.proto3","value":{"typeValue":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type","type":"type(int)"},{"original":{"name":"select_default","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"select","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}}},"value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":2}}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_big","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":108}}}},"value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":108}}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"select_neg","expr":"x.standalone_enum","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"container":"cel.expr.conformance.proto3","bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-3}}}},"value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":-3}}},"ast":"x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int","type":"int"},{"original":{"name":"field_type","expr":"type(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"typeValue":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"}},"ast":"type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type","type":"type(int)"},{"original":{"name":"assign_standalone_name","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAZ"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"assign_standalone_int","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":"BAR"}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^"},{"original":{"name":"assign_standalone_int_big","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":99}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 99^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}\n | .....................................................^"},{"original":{"name":"assign_standalone_int_neg","expr":"TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-1}}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","error":"ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}\n | .....................................................^"},{"original":{"name":"convert_symbol_to_int","expr":"int(GlobalEnum.GAZ)","container":"cel.expr.conformance.proto3","value":{"int64Value":"2"}},"ast":"int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~int^int64_to_int64","type":"int"},{"original":{"name":"convert_unnamed_to_int","description":"Disable check - missing way to declare enums.","expr":"int(x)","disableCheck":true,"bindings":{"x":{"value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum","value":444}}}},"value":{"int64Value":"444"}},"ast":"int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^"},{"original":{"name":"convert_unnamed_to_int_select","expr":"int(x.standalone_enum)","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","standaloneEnum":-987}}}},"value":{"int64Value":"-987"}},"ast":"int(\n x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int\n)~int^int64_to_int64","type":"int"},{"original":{"name":"convert_int_inrange","expr":"TestAllTypes.NestedEnum(2)","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(2)\n | .......................^"},{"original":{"name":"convert_int_big","expr":"TestAllTypes.NestedEnum(20000)","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":20000}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(20000)\n | .......................^"},{"original":{"name":"convert_int_neg","expr":"GlobalEnum(-33)","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.GlobalEnum","value":-33}}},"ast":"GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto3')\n | GlobalEnum(-33)\n | ..........^"},{"original":{"name":"convert_int_too_big","expr":"TestAllTypes.NestedEnum(5000000000)","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^"},{"original":{"name":"convert_int_too_neg","expr":"TestAllTypes.NestedEnum(-7000000000)","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"range"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^"},{"original":{"name":"convert_string","expr":"TestAllTypes.NestedEnum('BAZ')","container":"cel.expr.conformance.proto3","value":{"enumValue":{"type":"cel.expr.conformance.proto3.TestAllTypes.NestedEnum","value":2}}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BAZ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^"},{"original":{"name":"convert_string_bad","expr":"TestAllTypes.NestedEnum('BLETCH')","container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"invalid"}]}},"ast":"TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n \"BLETCH\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^"}]}]},{"name":"fields","suites":[{"name":"map_fields","tests":[{"original":{"name":"map_key_int64","expr":"{0:1,2:2,5:true}[5]","value":{"boolValue":true}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:true~bool\n }~map(int, dyn),\n 5~int\n)~dyn^index_map","type":"dyn"},{"original":{"name":"map_key_uint64","expr":"{0u:1u,2u:'happy',5u:3u}[2u]","value":{"stringValue":"happy"}},"ast":"_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:\"happy\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:\"happy\"~string,\n 5u~uint:3u~uint\n }~map(uint, dyn),\n 2u~uint\n)~dyn^index_map","type":"dyn"},{"original":{"name":"map_key_string","expr":"{'name':100u}['name']","value":{"uint64Value":"100"}},"ast":"_[_](\n {\n \"name\"^#*expr.Constant_StringValue#:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"name\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"name\"~string:100u~uint\n }~map(string, uint),\n \"name\"~string\n)~uint^index_map","type":"uint"},{"original":{"name":"map_key_bool","expr":"{true:5}[true]","value":{"int64Value":"5"}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:5~int\n }~map(bool, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_key_mixed_type","expr":"{true:1,2:2,5u:3}[true]","value":{"int64Value":"1"}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:1~int,\n 2~int:2~int,\n 5u~uint:3~int\n }~map(dyn, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_key_mixed_numbers_double_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[3.0]","value":{"doubleValue":3}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3~double\n)~double^index_map","type":"double"},{"original":{"name":"map_key_mixed_numbers_lossy_double_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[3.1]","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3.1~double\n)~double^index_map","type":"double"},{"original":{"name":"map_key_mixed_numbers_uint_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[2u]","value":{"doubleValue":2}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 2u~uint\n)~double^index_map","type":"double"},{"original":{"name":"map_key_mixed_numbers_int_key","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[1]","value":{"doubleValue":1}},"ast":"_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 1~int\n)~double^index_map","type":"double"},{"original":{"name":"map_field_access","expr":"x.name","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"INT64"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"name"},"value":{"int64Value":"1024"}}]}}}},"value":{"int64Value":"1024"}},"ast":"x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#","checkedAst":"x~map(string, int)^x.name~int","type":"int"},{"original":{"name":"map_no_such_key","expr":"{0:1,2:2,5:3}[1]","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n)~int^index_map","type":"int"},{"original":{"name":"map_no_such_key_or_false","expr":"dyn({0:1,2:2,5:3}[1]) || false","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_no_such_key_or_true","expr":"dyn({0:1,2:2,5:3}[1]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_no_such_key_and_false","expr":"dyn({0:1,2:2,5:3}[1]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_no_such_key_and_true","expr":"dyn({0:1,2:2,5:3}[1]) \u0026\u0026 true","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_bad_key_type","expr":"{0:1,2:2,5:3}[dyn(b'')]","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n)~int^index_map","type":"int"},{"original":{"name":"map_bad_key_type_or_false","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) || false","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_bad_key_type_or_true","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_bad_key_type_and_false","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_bad_key_type_and_true","expr":"dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 true","evalError":{"errors":[{"message":"no such key"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b\"\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b\"\"~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_field_select_no_such_key","expr":"x.name","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"evalError":{"errors":[{"message":"no such key: 'name'"}]}},"ast":"x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#","checkedAst":"x~map(string, string)^x.name~string","type":"string"},{"original":{"name":"map_field_select_no_such_key_or_false","expr":"dyn(x.name) || false","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"evalError":{"errors":[{"message":"no such key: 'name'"}]}},"ast":"_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_field_select_no_such_key_or_true","expr":"dyn(x.name) || true","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"value":{"boolValue":true}},"ast":"_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"map_field_select_no_such_key_and_false","expr":"dyn(x.name) \u0026\u0026 false","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_field_select_no_such_key_and_true","expr":"dyn(x.name) \u0026\u0026 true","typeEnv":[{"name":"x","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"x":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"holiday"},"value":{"stringValue":"field"}}]}}}},"evalError":{"errors":[{"message":"no such key: 'name'"}]}},"ast":"_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"map_value_null","expr":"{true:null}[true]","value":{"nullValue":null}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:null~null\n }~map(bool, null),\n true~bool\n)~null^index_map","type":"null"},{"original":{"name":"map_value_bool","expr":"{27:false}[27]","value":{"boolValue":false}},"ast":"_[_](\n {\n 27^#*expr.Constant_Int64Value#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 27^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 27~int:false~bool\n }~map(int, bool),\n 27~int\n)~bool^index_map","type":"bool"},{"original":{"name":"map_value_string","expr":"{'n':'x'}['n']","value":{"stringValue":"x"}},"ast":"_[_](\n {\n \"n\"^#*expr.Constant_StringValue#:\"x\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"n\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"n\"~string:\"x\"~string\n }~map(string, string),\n \"n\"~string\n)~string^index_map","type":"string"},{"original":{"name":"map_value_float","expr":"{3:15.15}[3]","value":{"doubleValue":15.15}},"ast":"_[_](\n {\n 3^#*expr.Constant_Int64Value#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 3~int:15.15~double\n }~map(int, double),\n 3~int\n)~double^index_map","type":"double"},{"original":{"name":"map_value_uint64","expr":"{0u:1u,2u:2u,5u:3u}[0u]","value":{"uint64Value":"1"}},"ast":"_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:2u~uint,\n 5u~uint:3u~uint\n }~map(uint, uint),\n 0u~uint\n)~uint^index_map","type":"uint"},{"original":{"name":"map_value_int64","expr":"{true:1,false:2}[true]","value":{"int64Value":"1"}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:1~int,\n false~bool:2~int\n }~map(bool, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_value_bytes","expr":"{0:b''}[0]","value":{"bytesValue":""}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:b\"\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:b\"\"~bytes\n }~map(int, bytes),\n 0~int\n)~bytes^index_map","type":"bytes"},{"original":{"name":"map_value_list","expr":"{0u:[1]}[0u]","value":{"listValue":{"values":[{"int64Value":"1"}]}}},"ast":"_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0u~uint:[\n 1~int\n ]~list(int)\n }~map(uint, list(int)),\n 0u~uint\n)~list(int)^index_map","type":"list(int)"},{"original":{"name":"map_value_map","expr":"{'map': {'k': 'v'}}['map']","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}}]}}},"ast":"_[_](\n {\n \"map\"^#*expr.Constant_StringValue#:{\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"map\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"map\"~string:{\n \"k\"~string:\"v\"~string\n }~map(string, string)\n }~map(string, map(string, string)),\n \"map\"~string\n)~map(string, string)^index_map","type":"map(string, string)"},{"original":{"name":"map_value_mix_type","expr":"{'map': {'k': 'v'}, 'list': [1]}['map']","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}}]}}},"ast":"_[_](\n {\n \"map\"^#*expr.Constant_StringValue#:{\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"list\"^#*expr.Constant_StringValue#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"map\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"map\"~string:{\n \"k\"~string:\"v\"~string\n }~map(string, string),\n \"list\"~string:[\n 1~int\n ]~list(int)\n }~map(string, dyn),\n \"map\"~string\n)~dyn^index_map","type":"dyn"}]},{"name":"map_has","tests":[{"original":{"name":"has","expr":"has({'a': 1, 'b': 2}.a)","value":{"boolValue":true}},"ast":"{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"a\"~string:1~int,\n \"b\"~string:2~int\n}~map(string, int).a~test-only~~bool","type":"bool"},{"original":{"name":"has_not","expr":"has({'a': 1, 'b': 2}.c)","value":{"boolValue":false}},"ast":"{\n \"a\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"b\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.c~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"a\"~string:1~int,\n \"b\"~string:2~int\n}~map(string, int).c~test-only~~bool","type":"bool"},{"original":{"name":"has_empty","expr":"has({}.a)","value":{"boolValue":false}},"ast":"{}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{}~map(dyn, dyn).a~test-only~~bool","type":"bool"}]},{"name":"quoted_map_fields","tests":[{"original":{"name":"field_access_slash","expr":"{'/api/v1': true, '/api/v2': false}.`/api/v1`","value":{"boolValue":true}},"error":"ERROR: field_access_slash:1:37: unsupported syntax: '`'\n | {'/api/v1': true, '/api/v2': false}.`/api/v1`\n | ....................................^"},{"original":{"name":"field_access_dash","expr":"{'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'","value":{"boolValue":true}},"error":"ERROR: field_access_dash:1:61: unsupported syntax: '`'\n | {'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'\n | ............................................................^"},{"original":{"name":"field_access_dot","expr":"{'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`","value":{"int64Value":"32"}},"error":"ERROR: field_access_dot:1:34: unsupported syntax: '`'\n | {'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`\n | .................................^"},{"original":{"name":"has_field_slash","expr":"has({'/api/v1': true, '/api/v2': false}.`/api/v3`)","value":{"boolValue":false}},"error":"ERROR: has_field_slash:1:41: unsupported syntax: '`'\n | has({'/api/v1': true, '/api/v2': false}.`/api/v3`)\n | ........................................^"},{"original":{"name":"has_field_dash","expr":"has({'content-type': 'application/json', 'content-length': 145}.`content-type`)","value":{"boolValue":true}},"error":"ERROR: has_field_dash:1:65: unsupported syntax: '`'\n | has({'content-type': 'application/json', 'content-length': 145}.`content-type`)\n | ................................................................^"},{"original":{"name":"has_field_dot","expr":"has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)","value":{"boolValue":true}},"error":"ERROR: has_field_dot:1:38: unsupported syntax: '`'\n | has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)\n | .....................................^"}]},{"name":"qualified_identifier_resolution","tests":[{"original":{"name":"qualified_ident","expr":"a.b.c","typeEnv":[{"name":"a.b.c","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"a.b.c":{"value":{"stringValue":"yeah"}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b.c~string^a.b.c","type":"string"},{"original":{"name":"map_field_select","expr":"a.b.c","typeEnv":[{"name":"a.b","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"yeah"}}]}}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b~map(string, string)^a.b.c~string","type":"string"},{"original":{"name":"qualified_identifier_resolution_unchecked","description":"namespace resolution should try to find the longest prefix for the evaluator.","expr":"a.b.c","disableCheck":true,"typeEnv":[{"name":"a.b.c","ident":{"type":{"primitive":"STRING"}}},{"name":"a.b","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"oops"}}]}}},"a.b.c":{"value":{"stringValue":"yeah"}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b.c~string^a.b.c","type":"string"},{"original":{"name":"list_field_select_unsupported","expr":"a.b.pancakes","disableCheck":true,"typeEnv":[{"name":"a.b","ident":{"type":{"listType":{"elemType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"listValue":{"values":[{"stringValue":"pancakes"}]}}}},"evalError":{"errors":[{"message":"type 'list_type:\u003celem_type:\u003cprimitive:STRING \u003e \u003e ' does not support field selection"}]}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.pancakes^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:4: type 'list(string)' does not support field selection\n | a.b.pancakes\n | ...^"},{"original":{"name":"int64_field_select_unsupported","expr":"a.pancakes","disableCheck":true,"typeEnv":[{"name":"a","ident":{"type":{"primitive":"INT64"}}}],"bindings":{"a":{"value":{"int64Value":"15"}}},"evalError":{"errors":[{"message":"type 'int64_type' does not support field selection"}]}},"ast":"a^#*expr.Expr_IdentExpr#.pancakes^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:2: type 'int' does not support field selection\n | a.pancakes\n | .^"},{"original":{"name":"ident_with_longest_prefix_check","description":"namespace resolution should try to find the longest prefix for the checker.","expr":"a.b.c","typeEnv":[{"name":"a.b.c","ident":{"type":{"primitive":"STRING"}}},{"name":"a.b","ident":{"type":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"STRING"}}}}}],"bindings":{"a.b":{"value":{"mapValue":{"entries":[{"key":{"stringValue":"c"},"value":{"stringValue":"oops"}}]}}},"a.b.c":{"value":{"stringValue":"yeah"}}},"value":{"stringValue":"yeah"}},"ast":"a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#","checkedAst":"a.b.c~string^a.b.c","type":"string"},{"original":{"name":"map_key_float","description":"map should not support float as the key.","expr":"{3.3:15.15, 1.0: 5}[1.0]","disableCheck":true,"evalError":{"errors":[{"message":"unsupported key type"}]}},"ast":"_[_](\n {\n 3.3^#*expr.Constant_DoubleValue#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_DoubleValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 3.3~double:15.15~double,\n 1~double:5~int\n }~map(double, dyn),\n 1~double\n)~dyn^index_map","type":"dyn"},{"original":{"name":"map_key_null","description":"map should not support null as the key.","expr":"{null:false}[null]","disableCheck":true,"evalError":{"errors":[{"message":"unsupported key type"}]}},"ast":"_[_](\n {\n null^#*expr.Constant_NullValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n null~null:false~bool\n }~map(null, bool),\n null~null\n)~bool^index_map","type":"bool"},{"original":{"name":"map_value_repeat_key","description":"map should not support repeated key.","expr":"{true:1,false:2,true:3}[true]","evalError":{"errors":[{"message":"Failed with repeated key"}]}},"ast":"_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n true~bool:1~int,\n false~bool:2~int,\n true~bool:3~int\n }~map(bool, int),\n true~bool\n)~int^index_map","type":"int"},{"original":{"name":"map_value_repeat_key_heterogeneous","description":"map should not support repeated key.","expr":"{0: 1, 0u: 2}[0.0]","evalError":{"errors":[{"message":"Failed with repeated key"}]}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 0u^#*expr.Constant_Uint64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:1~int,\n 0u~uint:2~int\n }~map(dyn, int),\n 0~double\n)~int^index_map","type":"int"}]},{"name":"in","tests":[{"original":{"name":"empty","expr":"7 in {}","value":{"boolValue":false}},"ast":"@in(\n 7^#*expr.Constant_Int64Value#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 7~int,\n {}~map(int, dyn)\n)~bool^in_map","type":"bool"},{"original":{"name":"singleton","expr":"true in {true: 1}","value":{"boolValue":true}},"ast":"@in(\n true^#*expr.Constant_BoolValue#,\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n true~bool,\n {\n true~bool:1~int\n }~map(bool, int)\n)~bool^in_map","type":"bool"},{"original":{"name":"present","expr":"'George' in {'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}","value":{"boolValue":true}},"ast":"@in(\n \"George\"^#*expr.Constant_StringValue#,\n {\n \"John\"^#*expr.Constant_StringValue#:\"smart\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Paul\"^#*expr.Constant_StringValue#:\"cute\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"George\"^#*expr.Constant_StringValue#:\"quiet\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Ringo\"^#*expr.Constant_StringValue#:\"funny\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"George\"~string,\n {\n \"John\"~string:\"smart\"~string,\n \"Paul\"~string:\"cute\"~string,\n \"George\"~string:\"quiet\"~string,\n \"Ringo\"~string:\"funny\"~string\n }~map(string, string)\n)~bool^in_map","type":"bool"},{"original":{"name":"absent","expr":"'spider' in {'ant': 6, 'fly': 6, 'centipede': 100}","value":{"boolValue":false}},"ast":"@in(\n \"spider\"^#*expr.Constant_StringValue#,\n {\n \"ant\"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"fly\"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"centipede\"^#*expr.Constant_StringValue#:100^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"spider\"~string,\n {\n \"ant\"~string:6~int,\n \"fly\"~string:6~int,\n \"centipede\"~string:100~int\n }~map(string, int)\n)~bool^in_map","type":"bool"},{"original":{"name":"mixed_numbers_and_keys_present","expr":"3.0 in {1: 1, 2: 2, 3u: 3} \u0026\u0026 2u in {1u: 1, 2: 2} \u0026\u0026 1 in {1u: 1, 2: 2}","value":{"boolValue":true}},"ast":"_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2u^#*expr.Constant_Uint64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n )~bool^in_map,\n @in(\n 2u~uint,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n )~bool^logical_and,\n @in(\n 1~int,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n)~bool^logical_and","type":"bool"},{"original":{"name":"mixed_numbers_and_keys_absent","expr":"3.1 in {1: 1, 2: 2, 3u: 3}","value":{"boolValue":false}},"ast":"@in(\n 3.1^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 3.1~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n)~bool^in_map","type":"bool"}]}]},{"name":"fp_math","suites":[{"name":"fp_math","tests":[{"original":{"name":"add_positive_positive","expr":"4.25 + 15.25","value":{"doubleValue":19.5}},"ast":"_+_(\n 4.25^#*expr.Constant_DoubleValue#,\n 15.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 4.25~double,\n 15.25~double\n)~double^add_double","type":"double"},{"original":{"name":"add_positive_negative","expr":"17.75 + (-7.75)","value":{"doubleValue":10}},"ast":"_+_(\n 17.75^#*expr.Constant_DoubleValue#,\n -7.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 17.75~double,\n -7.75~double\n)~double^add_double","type":"double"},{"original":{"name":"add_negative_negative","expr":"-4.125 + (-2.125)","value":{"doubleValue":-6.25}},"ast":"_+_(\n -4.125^#*expr.Constant_DoubleValue#,\n -2.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n -4.125~double,\n -2.125~double\n)~double^add_double","type":"double"},{"original":{"name":"sub_positive_positive","expr":"42.0 - 12.0","value":{"doubleValue":30}},"ast":"_-_(\n 42^#*expr.Constant_DoubleValue#,\n 12^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42~double,\n 12~double\n)~double^subtract_double","type":"double"},{"original":{"name":"sub_positive_negative","expr":"42.875 - (-22.0)","value":{"doubleValue":64.875}},"ast":"_-_(\n 42.875^#*expr.Constant_DoubleValue#,\n -22^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42.875~double,\n -22~double\n)~double^subtract_double","type":"double"},{"original":{"name":"sub_negative_negative","expr":"-4.875 - (-0.125)","value":{"doubleValue":-4.75}},"ast":"_-_(\n -4.875^#*expr.Constant_DoubleValue#,\n -0.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n -4.875~double,\n -0.125~double\n)~double^subtract_double","type":"double"},{"original":{"name":"multiply_positive_positive","expr":"42.5 * 0.2","value":{"doubleValue":8.5}},"ast":"_*_(\n 42.5^#*expr.Constant_DoubleValue#,\n 0.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 42.5~double,\n 0.2~double\n)~double^multiply_double","type":"double"},{"original":{"name":"multiply_positive_negative","expr":"40.75 * (-2.25)","value":{"doubleValue":-91.6875}},"ast":"_*_(\n 40.75^#*expr.Constant_DoubleValue#,\n -2.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 40.75~double,\n -2.25~double\n)~double^multiply_double","type":"double"},{"original":{"name":"multiply_negative_negative","expr":"-3.0 * (-2.5)","value":{"doubleValue":7.5}},"ast":"_*_(\n -3^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -3~double,\n -2.5~double\n)~double^multiply_double","type":"double"},{"original":{"name":"divide_positive_positive","expr":"0.0625 / 0.002","value":{"doubleValue":31.25}},"ast":"_/_(\n 0.0625^#*expr.Constant_DoubleValue#,\n 0.002^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 0.0625~double,\n 0.002~double\n)~double^divide_double","type":"double"},{"original":{"name":"divide_positive_negative","expr":"-2.0 / 2.0","value":{"doubleValue":-1}},"ast":"_/_(\n -2^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -2~double,\n 2~double\n)~double^divide_double","type":"double"},{"original":{"name":"divide_negative_negative","expr":"-8.875 / (-0.0625)","value":{"doubleValue":142}},"ast":"_/_(\n -8.875^#*expr.Constant_DoubleValue#,\n -0.0625^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -8.875~double,\n -0.0625~double\n)~double^divide_double","type":"double"},{"original":{"name":"mod_not_support","expr":"47.5 % 5.5","disableCheck":true,"evalError":{"errors":[{"message":"found no matching overload for '_%_' applied to '(double, double)'"}]}},"ast":"_%_(\n 47.5^#*expr.Constant_DoubleValue#,\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:6: found no matching overload for '_%_' applied to '(double, double)'\n | 47.5 % 5.5\n | .....^"},{"original":{"name":"negative","expr":"-(4.5)","value":{"doubleValue":-4.5}},"ast":"-_(\n 4.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 4.5~double\n)~double^negate_double","type":"double"},{"original":{"name":"double_negative","expr":"-(-1.25)","value":{"doubleValue":1.25}},"ast":"-_(\n -1.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -1.25~double\n)~double^negate_double","type":"double"},{"original":{"name":"negative_zero","expr":"-(0.0)","value":{"doubleValue":0}},"ast":"-_(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 0~double\n)~double^negate_double","type":"double"},{"original":{"name":"divide_zero","expr":"15.75 / 0.0","value":{"doubleValue":"Infinity"}},"ast":"_/_(\n 15.75^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 15.75~double,\n 0~double\n)~double^divide_double","type":"double"},{"original":{"name":"multiply_zero","expr":"15.36 * 0.0","value":{"doubleValue":0}},"ast":"_*_(\n 15.36^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 15.36~double,\n 0~double\n)~double^multiply_double","type":"double"},{"original":{"name":"add_left_identity","expr":"0.0 + 1.75","value":{"doubleValue":1.75}},"ast":"_+_(\n 0^#*expr.Constant_DoubleValue#,\n 1.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 0~double,\n 1.75~double\n)~double^add_double","type":"double"},{"original":{"name":"add_right_identity","expr":" 2.5 + 0.0","value":{"doubleValue":2.5}},"ast":"_+_(\n 2.5^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 2.5~double,\n 0~double\n)~double^add_double","type":"double"},{"original":{"name":"add_commutative","expr":"7.5 + 1.5 == 1.5 + 7.5","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 7.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 7.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 7.5~double,\n 1.5~double\n )~double^add_double,\n _+_(\n 1.5~double,\n 7.5~double\n )~double^add_double\n)~bool^equals","type":"bool"},{"original":{"name":"add_associative","expr":"5.625 + (15.75 + 2.0) == (5.625 + 15.75) + 2.0","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n _+_(\n 15.75^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n 15.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 5.625~double,\n _+_(\n 15.75~double,\n 2~double\n )~double^add_double\n )~double^add_double,\n _+_(\n _+_(\n 5.625~double,\n 15.75~double\n )~double^add_double,\n 2~double\n )~double^add_double\n)~bool^equals","type":"bool"},{"original":{"name":"mul_left_identity","expr":"1.0 * 45.25","value":{"doubleValue":45.25}},"ast":"_*_(\n 1^#*expr.Constant_DoubleValue#,\n 45.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 1~double,\n 45.25~double\n)~double^multiply_double","type":"double"},{"original":{"name":"mul_right_identity","expr":"-25.25 * 1.0","value":{"doubleValue":-25.25}},"ast":"_*_(\n -25.25^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -25.25~double,\n 1~double\n)~double^multiply_double","type":"double"},{"original":{"name":"mul_commutative","expr":"1.5 * 25.875 == 25.875 * 1.5","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 25.875^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25.875^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 1.5~double,\n 25.875~double\n )~double^multiply_double,\n _*_(\n 25.875~double,\n 1.5~double\n )~double^multiply_double\n)~bool^equals","type":"bool"},{"original":{"name":"mul_associative","expr":"1.5 * (23.625 * 0.75) == (1.5 * 23.625) * 0.75","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n _*_(\n 23.625^#*expr.Constant_DoubleValue#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 23.625^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 1.5~double,\n _*_(\n 23.625~double,\n 0.75~double\n )~double^multiply_double\n )~double^multiply_double,\n _*_(\n _*_(\n 1.5~double,\n 23.625~double\n )~double^multiply_double,\n 0.75~double\n )~double^multiply_double\n)~bool^equals","type":"bool"},{"original":{"name":"add_mul_distribute","expr":"5.75 * (1.5 + 2.5) == 5.75 * 1.5 + 5.75 * 2.5","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 5.75~double,\n _+_(\n 1.5~double,\n 2.5~double\n )~double^add_double\n )~double^multiply_double,\n _+_(\n _*_(\n 5.75~double,\n 1.5~double\n )~double^multiply_double,\n _*_(\n 5.75~double,\n 2.5~double\n )~double^multiply_double\n )~double^add_double\n)~bool^equals","type":"bool"},{"original":{"name":"fp_overflow_positive","description":"DBL_MAX(2^1023) times two","expr":"2.0 * 8.988466e+307 ","value":{"doubleValue":"Infinity"}},"ast":"_*_(\n 2^#*expr.Constant_DoubleValue#,\n 8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 2~double,\n 8.988466e+307~double\n)~double^multiply_double","type":"double"},{"original":{"name":"fp_overflow_negative","description":"-DBL_MAX(-2^1023) times two","expr":"2.0 * -8.988466e+307 ","value":{"doubleValue":"-Infinity"}},"ast":"_*_(\n 2^#*expr.Constant_DoubleValue#,\n -8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 2~double,\n -8.988466e+307~double\n)~double^multiply_double","type":"double"},{"original":{"name":"fp_underflow","description":"DBL_MIN(2^-1074) divided by two","expr":"1e-324 / 2.0","value":{"doubleValue":0}},"ast":"_/_(\n 0^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 0~double,\n 2~double\n)~double^divide_double","type":"double"}]}]},{"name":"integer_math","suites":[{"name":"int64_math","tests":[{"original":{"name":"add_positive_positive","expr":"40 + 2","value":{"int64Value":"42"}},"ast":"_+_(\n 40^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 40~int,\n 2~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_positive_negative","expr":"42 + (-7)","value":{"int64Value":"35"}},"ast":"_+_(\n 42^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 42~int,\n -7~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_negative_negative","expr":"-4 + (-2)","value":{"int64Value":"-6"}},"ast":"_+_(\n -4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n -4~int,\n -2~int\n)~int^add_int64","type":"int"},{"original":{"name":"sub_positive_positive","expr":"42 - 12","value":{"int64Value":"30"}},"ast":"_-_(\n 42^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42~int,\n 12~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"sub_positive_negative","expr":"42 - (-22)","value":{"int64Value":"64"}},"ast":"_-_(\n 42^#*expr.Constant_Int64Value#,\n -22^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42~int,\n -22~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"sub_negative_negative","expr":"-42 - (-12)","value":{"int64Value":"-30"}},"ast":"_-_(\n -42^#*expr.Constant_Int64Value#,\n -12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n -42~int,\n -12~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"multiply_positive_positive","expr":"42 * 2","value":{"int64Value":"84"}},"ast":"_*_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 42~int,\n 2~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"multiply_positive_negative","expr":"40 * (-2)","value":{"int64Value":"-80"}},"ast":"_*_(\n 40^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 40~int,\n -2~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"multiply_negative_negative","expr":"-30 * (-2)","value":{"int64Value":"60"}},"ast":"_*_(\n -30^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -30~int,\n -2~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"divide_positive_positive","expr":"42 / 2","value":{"int64Value":"21"}},"ast":"_/_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 42~int,\n 2~int\n)~int^divide_int64","type":"int"},{"original":{"name":"divide_positive_negative","expr":"-20 / 2","value":{"int64Value":"-10"}},"ast":"_/_(\n -20^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -20~int,\n 2~int\n)~int^divide_int64","type":"int"},{"original":{"name":"divide_negative_negative","expr":"-80 / (-2)","value":{"int64Value":"40"}},"ast":"_/_(\n -80^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -80~int,\n -2~int\n)~int^divide_int64","type":"int"},{"original":{"name":"mod_positive_positive","expr":"47 % 5","value":{"int64Value":"2"}},"ast":"_%_(\n 47^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 47~int,\n 5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"mod_positive_negative","expr":"43 % (-5)","value":{"int64Value":"3"}},"ast":"_%_(\n 43^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 43~int,\n -5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"mod_negative_negative","expr":"-42 % (-5)","value":{"int64Value":"-2"}},"ast":"_%_(\n -42^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n -42~int,\n -5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"mod_negative_positive","expr":"-3 % 5","value":{"int64Value":"-3"}},"ast":"_%_(\n -3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n -3~int,\n 5~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"unary_minus_pos","expr":"-(42)","value":{"int64Value":"-42"}},"ast":"-_(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 42~int\n)~int^negate_int64","type":"int"},{"original":{"name":"unary_minus_neg","expr":"-(-42)","value":{"int64Value":"42"}},"ast":"-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -42~int\n)~int^negate_int64","type":"int"},{"original":{"name":"unary_minus_no_overload","expr":"-(42u)","disableCheck":true,"evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"-_(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(42u)\n | ^"},{"original":{"name":"unary_minus_not_bool","expr":"-false","disableCheck":true,"evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"-_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(bool)'\n | -false\n | ^"},{"original":{"name":"mod_zero","expr":"34 % 0","evalError":{"errors":[{"message":"modulus by zero"}]}},"ast":"_%_(\n 34^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 34~int,\n 0~int\n)~int^modulo_int64","type":"int"},{"original":{"name":"negative_zero","expr":"-(0)","value":{"int64Value":"0"}},"ast":"-_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n 0~int\n)~int^negate_int64","type":"int"},{"original":{"name":"double_negative","expr":"-(-42)","value":{"int64Value":"42"}},"ast":"-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -42~int\n)~int^negate_int64","type":"int"},{"original":{"name":"divide_zero","expr":"15 / 0","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"_/_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 15~int,\n 0~int\n)~int^divide_int64","type":"int"},{"original":{"name":"multiply_zero","expr":"15 * 0","value":{"int64Value":"0"}},"ast":"_*_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 15~int,\n 0~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"add_left_identity","expr":"0 + 17","value":{"int64Value":"17"}},"ast":"_+_(\n 0^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 0~int,\n 17~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_right_identity","expr":" 29 + 0","value":{"int64Value":"29"}},"ast":"_+_(\n 29^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 29~int,\n 0~int\n)~int^add_int64","type":"int"},{"original":{"name":"add_commutative","expr":"75 + 15 == 15 + 75","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 75^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 75~int,\n 15~int\n )~int^add_int64,\n _+_(\n 15~int,\n 75~int\n )~int^add_int64\n)~bool^equals","type":"bool"},{"original":{"name":"add_associative","expr":"5 + (15 + 20) == (5 + 15) + 20","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 5~int,\n _+_(\n 15~int,\n 20~int\n )~int^add_int64\n )~int^add_int64,\n _+_(\n _+_(\n 5~int,\n 15~int\n )~int^add_int64,\n 20~int\n )~int^add_int64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_left_identity","expr":"1 * 45","value":{"int64Value":"45"}},"ast":"_*_(\n 1^#*expr.Constant_Int64Value#,\n 45^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 1~int,\n 45~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"mul_right_identity","expr":"-25 * 1","value":{"int64Value":"-25"}},"ast":"_*_(\n -25^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -25~int,\n 1~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"mul_commutative","expr":"15 * 25 == 25 * 15","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15~int,\n 25~int\n )~int^multiply_int64,\n _*_(\n 25~int,\n 15~int\n )~int^multiply_int64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_associative","expr":"15 * (23 * 88) == (15 * 23) * 88","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n _*_(\n 23^#*expr.Constant_Int64Value#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15~int,\n _*_(\n 23~int,\n 88~int\n )~int^multiply_int64\n )~int^multiply_int64,\n _*_(\n _*_(\n 15~int,\n 23~int\n )~int^multiply_int64,\n 88~int\n )~int^multiply_int64\n)~bool^equals","type":"bool"},{"original":{"name":"add_mul_distribute","expr":"5 * (15 + 25) == 5 * 15 + 5 * 25","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 5~int,\n _+_(\n 15~int,\n 25~int\n )~int^add_int64\n )~int^multiply_int64,\n _+_(\n _*_(\n 5~int,\n 15~int\n )~int^multiply_int64,\n _*_(\n 5~int,\n 25~int\n )~int^multiply_int64\n )~int^add_int64\n)~bool^equals","type":"bool"},{"original":{"name":"int64_overflow_positive","description":"LLONG_MAX plus one.","expr":"9223372036854775807 + 1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_+_(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 9223372036854775807~int,\n 1~int\n)~int^add_int64","type":"int"},{"original":{"name":"int64_overflow_negative","description":"LLONG_MIN minus one.","expr":"-9223372036854775808 - 1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_-_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n -9223372036854775808~int,\n 1~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"int64_overflow_add_negative","description":"negative overflow via addition","expr":"-9223372036854775808 + (-1)","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_+_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n -9223372036854775808~int,\n -1~int\n)~int^add_int64","type":"int"},{"original":{"name":"int64_overflow_sub_positive","description":"positive overflow via subtraction","expr":"1 - (-9223372036854775807)","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_-_(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 1~int,\n -9223372036854775807~int\n)~int^subtract_int64","type":"int"},{"original":{"name":"int64_min_negate","description":"Negated LLONG_MIN is not representable.","expr":"-(-9223372036854775808)","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"-_(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"-_(\n -9223372036854775808~int\n)~int^negate_int64","type":"int"},{"original":{"name":"int64_min_negate_mul","description":"Negate LLONG_MIN via multiplication","expr":"(-9223372036854775808) * -1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -9223372036854775808~int,\n -1~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"int64_min_negate_div","description":"Negate LLONG_MIN via division.","expr":"(-9223372036854775808)/-1","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_/_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n -9223372036854775808~int,\n -1~int\n)~int^divide_int64","type":"int"},{"original":{"name":"int64_overflow_mul_positive","description":"Overflow via multiplication.","expr":"5000000000 * 5000000000","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n 5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 5000000000~int,\n 5000000000~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"int64_overflow_mul_negative","description":"Overflow via multiplication.","expr":"(-5000000000) * 5000000000","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n -5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n -5000000000~int,\n 5000000000~int\n)~int^multiply_int64","type":"int"},{"original":{"name":"uint64_overflow_positive","description":"ULLONG_MAX plus one.","expr":"18446744073709551615u + 1u","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_+_(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"uint64_overflow_negative","description":"zero minus one.","expr":"0u - 1u","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_-_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 0u~uint,\n 1u~uint\n)~uint^subtract_uint64","type":"uint"},{"original":{"name":"uint64_overflow_mul_positive","description":"Overflow via multiplication.","expr":"5000000000u * 5000000000u","evalError":{"errors":[{"message":"return error for overflow"}]}},"ast":"_*_(\n 5000000000u^#*expr.Constant_Uint64Value#,\n 5000000000u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 5000000000u~uint,\n 5000000000u~uint\n)~uint^multiply_uint64","type":"uint"}]},{"name":"uint64_math","tests":[{"original":{"name":"add","expr":"42u + 2u","value":{"uint64Value":"44"}},"ast":"_+_(\n 42u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 42u~uint,\n 2u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"sub","expr":"42u - 12u","value":{"uint64Value":"30"}},"ast":"_-_(\n 42u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n 42u~uint,\n 12u~uint\n)~uint^subtract_uint64","type":"uint"},{"original":{"name":"multiply","expr":"40u * 2u","value":{"uint64Value":"80"}},"ast":"_*_(\n 40u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 40u~uint,\n 2u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"divide","expr":"60u / 2u","value":{"uint64Value":"30"}},"ast":"_/_(\n 60u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 60u~uint,\n 2u~uint\n)~uint^divide_uint64","type":"uint"},{"original":{"name":"mod","expr":"42u % 5u","value":{"uint64Value":"2"}},"ast":"_%_(\n 42u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 42u~uint,\n 5u~uint\n)~uint^modulo_uint64","type":"uint"},{"original":{"name":"negative_no_overload","expr":"-(5u)","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"-_(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(5u)\n | ^"},{"original":{"name":"mod_zero","expr":"34u % 0u","evalError":{"errors":[{"message":"modulus by zero"}]}},"ast":"_%_(\n 34u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_%_(\n 34u~uint,\n 0u~uint\n)~uint^modulo_uint64","type":"uint"},{"original":{"name":"divide_zero","expr":"15u / 0u","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"_/_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 15u~uint,\n 0u~uint\n)~uint^divide_uint64","type":"uint"},{"original":{"name":"multiply_zero","expr":"15u * 0u","value":{"uint64Value":"0"}},"ast":"_*_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 15u~uint,\n 0u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"add_left_identity","expr":"0u + 17u","value":{"uint64Value":"17"}},"ast":"_+_(\n 0u^#*expr.Constant_Uint64Value#,\n 17u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 0u~uint,\n 17u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"add_right_identity","expr":" 29u + 0u","value":{"uint64Value":"29"}},"ast":"_+_(\n 29u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n 29u~uint,\n 0u~uint\n)~uint^add_uint64","type":"uint"},{"original":{"name":"add_commutative","expr":"75u + 15u == 15u + 75u","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 75u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 75u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 75u~uint,\n 15u~uint\n )~uint^add_uint64,\n _+_(\n 15u~uint,\n 75u~uint\n )~uint^add_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"add_associative","expr":"5u + (15u + 20u) == (5u + 15u) + 20u","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n 5u~uint,\n _+_(\n 15u~uint,\n 20u~uint\n )~uint^add_uint64\n )~uint^add_uint64,\n _+_(\n _+_(\n 5u~uint,\n 15u~uint\n )~uint^add_uint64,\n 20u~uint\n )~uint^add_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_left_identity","expr":"1u * 45u","value":{"uint64Value":"45"}},"ast":"_*_(\n 1u^#*expr.Constant_Uint64Value#,\n 45u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 1u~uint,\n 45u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"mul_right_identity","expr":"25u * 1u","value":{"uint64Value":"25"}},"ast":"_*_(\n 25u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_*_(\n 25u~uint,\n 1u~uint\n)~uint^multiply_uint64","type":"uint"},{"original":{"name":"mul_commutative","expr":"15u * 25u == 25u * 15u","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15u~uint,\n 25u~uint\n )~uint^multiply_uint64,\n _*_(\n 25u~uint,\n 15u~uint\n )~uint^multiply_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"mul_associative","expr":"15u * (23u * 88u) == (15u * 23u) * 88u","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n _*_(\n 23u^#*expr.Constant_Uint64Value#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 23u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 15u~uint,\n _*_(\n 23u~uint,\n 88u~uint\n )~uint^multiply_uint64\n )~uint^multiply_uint64,\n _*_(\n _*_(\n 15u~uint,\n 23u~uint\n )~uint^multiply_uint64,\n 88u~uint\n )~uint^multiply_uint64\n)~bool^equals","type":"bool"},{"original":{"name":"add_mul_distribute","expr":"5u * (15u + 25u) == 5u * 15u + 5u * 25u","value":{"boolValue":true}},"ast":"_==_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _*_(\n 5u~uint,\n _+_(\n 15u~uint,\n 25u~uint\n )~uint^add_uint64\n )~uint^multiply_uint64,\n _+_(\n _*_(\n 5u~uint,\n 15u~uint\n )~uint^multiply_uint64,\n _*_(\n 5u~uint,\n 25u~uint\n )~uint^multiply_uint64\n )~uint^add_uint64\n)~bool^equals","type":"bool"}]}]},{"name":"lists","suites":[{"name":"concatenation","tests":[{"original":{"name":"list_append","expr":"[0, 1, 2] + [3, 4, 5] == [0, 1, 2, 3, 4, 5]","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"list_not_commutative","expr":"[0, 1, 2] + [3, 4, 5] == [3, 4, 5, 0, 1, 2]","value":{"boolValue":false}},"ast":"_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 3~int,\n 4~int,\n 5~int,\n 0~int,\n 1~int,\n 2~int\n ]~list(int)\n)~bool^equals","type":"bool"},{"original":{"name":"list_repeat","expr":"[2] + [2]","value":{"listValue":{"values":[{"int64Value":"2"},{"int64Value":"2"}]}}},"ast":"_+_(\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n [\n 2~int\n ]~list(int),\n [\n 2~int\n ]~list(int)\n)~list(int)^add_list","type":"list(int)"},{"original":{"name":"empty_empty","expr":"[] + []","value":{"listValue":{}}},"ast":"_+_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n []~list(dyn),\n []~list(dyn)\n)~list(dyn)^add_list","type":"list(dyn)"},{"original":{"name":"left_unit","expr":"[] + [3, 4]","value":{"listValue":{"values":[{"int64Value":"3"},{"int64Value":"4"}]}}},"ast":"_+_(\n []^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n []~list(int),\n [\n 3~int,\n 4~int\n ]~list(int)\n)~list(int)^add_list","type":"list(int)"},{"original":{"name":"right_unit","expr":"[1, 2] + []","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"}]}}},"ast":"_+_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n [\n 1~int,\n 2~int\n ]~list(int),\n []~list(int)\n)~list(int)^add_list","type":"list(int)"}]},{"name":"index","tests":[{"original":{"name":"zero_based","expr":"[7, 8, 9][0]","value":{"int64Value":"7"}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n 0~int\n)~int^index_list","type":"int"},{"original":{"name":"zero_based_double","expr":"[7, 8, 9][dyn(0.0)]","value":{"int64Value":"7"}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0~double\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"zero_based_double_error","expr":"[7, 8, 9][dyn(0.1)]","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0.1~double\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"zero_based_uint","expr":"[7, 8, 9][dyn(0u)]","value":{"int64Value":"7"}},"ast":"_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0u~uint\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"singleton","expr":"['foo'][0]","value":{"stringValue":"foo"}},"ast":"_[_](\n [\n \"foo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n \"foo\"~string\n ]~list(string),\n 0~int\n)~string^index_list","type":"string"},{"original":{"name":"middle","expr":"[0, 1, 1, 2, 3, 5, 8, 13][4]","value":{"int64Value":"3"}},"ast":"_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 0~int,\n 1~int,\n 1~int,\n 2~int,\n 3~int,\n 5~int,\n 8~int,\n 13~int\n ]~list(int),\n 4~int\n)~int^index_list","type":"int"},{"original":{"name":"last","expr":"['George', 'John', 'Paul', 'Ringo'][3]","value":{"stringValue":"Ringo"}},"ast":"_[_](\n [\n \"George\"^#*expr.Constant_StringValue#,\n \"John\"^#*expr.Constant_StringValue#,\n \"Paul\"^#*expr.Constant_StringValue#,\n \"Ringo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n \"George\"~string,\n \"John\"~string,\n \"Paul\"~string,\n \"Ringo\"~string\n ]~list(string),\n 3~int\n)~string^index_list","type":"string"},{"original":{"name":"index_out_of_bounds","expr":"[1, 2, 3][3]","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n)~int^index_list","type":"int"},{"original":{"name":"index_out_of_bounds_or_false","expr":"dyn([1, 2, 3][3]) || false","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"index_out_of_bounds_or_true","expr":"dyn([1, 2, 3][3]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"index_out_of_bounds_and_false","expr":"dyn([1, 2, 3][3]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"index_out_of_bounds_and_true","expr":"dyn([1, 2, 3][3]) \u0026\u0026 true","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"bad_index_type","expr":"[1, 2, 3][dyn('')]","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n)~int^index_list","type":"int"},{"original":{"name":"bad_index_type_or_false","expr":"dyn([1, 2, 3][dyn('')]) || false","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"bad_index_type_or_true","expr":"dyn([1, 2, 3][dyn('')]) || true","value":{"boolValue":true}},"ast":"_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"bad_index_type_and_false","expr":"dyn([1, 2, 3][dyn('')]) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"bad_index_type_and_true","expr":"dyn([1, 2, 3][dyn('')]) \u0026\u0026 true","evalError":{"errors":[{"message":"invalid_argument"}]}},"ast":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n \"\"~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and","type":"bool"}]},{"name":"in","tests":[{"original":{"name":"empty","expr":"7 in []","value":{"boolValue":false}},"ast":"@in(\n 7^#*expr.Constant_Int64Value#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 7~int,\n []~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"singleton","expr":"4u in [4u]","value":{"boolValue":true}},"ast":"@in(\n 4u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 4u~uint,\n [\n 4u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"first","expr":"'alpha' in ['alpha', 'beta', 'gamma']","value":{"boolValue":true}},"ast":"@in(\n \"alpha\"^#*expr.Constant_StringValue#,\n [\n \"alpha\"^#*expr.Constant_StringValue#,\n \"beta\"^#*expr.Constant_StringValue#,\n \"gamma\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"alpha\"~string,\n [\n \"alpha\"~string,\n \"beta\"~string,\n \"gamma\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"},{"original":{"name":"middle","expr":"3 in [5, 4, 3, 2, 1]","value":{"boolValue":true}},"ast":"@in(\n 3^#*expr.Constant_Int64Value#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 3~int,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"last","expr":"20u in [4u, 6u, 8u, 12u, 20u]","value":{"boolValue":true}},"ast":"@in(\n 20u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#,\n 6u^#*expr.Constant_Uint64Value#,\n 8u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n 20u~uint,\n [\n 4u~uint,\n 6u~uint,\n 8u~uint,\n 12u~uint,\n 20u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"double_in_ints","expr":"dyn(3.0) in [5, 4, 3, 2, 1]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"uint_in_ints","expr":"dyn(3u) in [5, 4, 3, 2, 1]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list","type":"bool"},{"original":{"name":"int_in_doubles","expr":"dyn(3) in [5.0, 4.0, 3.0, 2.0, 1.0]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list","type":"bool"},{"original":{"name":"uint_in_doubles","expr":"dyn(3u) in [5.0, 4.0, 3.0, 2.0, 1.0]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list","type":"bool"},{"original":{"name":"int_in_uints","expr":"dyn(3) in [5u, 4u, 3u, 2u, 1u]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"double_in_uints","expr":"dyn(3.0) in [5u, 4u, 3u, 2u, 1u]","value":{"boolValue":true}},"ast":"@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list","type":"bool"},{"original":{"name":"missing","expr":"'hawaiian' in ['meat', 'veggie', 'margarita', 'cheese']","value":{"boolValue":false}},"ast":"@in(\n \"hawaiian\"^#*expr.Constant_StringValue#,\n [\n \"meat\"^#*expr.Constant_StringValue#,\n \"veggie\"^#*expr.Constant_StringValue#,\n \"margarita\"^#*expr.Constant_StringValue#,\n \"cheese\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"@in(\n \"hawaiian\"~string,\n [\n \"meat\"~string,\n \"veggie\"~string,\n \"margarita\"~string,\n \"cheese\"~string\n ]~list(string)\n)~bool^in_list","type":"bool"}]},{"name":"size","tests":[{"original":{"name":"list_empty","expr":"size([])","value":{"int64Value":"0"}},"ast":"size(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n []~list(dyn)\n)~int^size_list","type":"int"},{"original":{"name":"list","expr":"size([1, 2, 3])","value":{"int64Value":"3"}},"ast":"size(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~int^size_list","type":"int"},{"original":{"name":"map_empty","expr":"size({})","value":{"int64Value":"0"}},"ast":"size(\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n {}~map(dyn, dyn)\n)~int^size_map","type":"int"},{"original":{"name":"map","expr":"size({1: 'one', 2: 'two', 3: 'three'})","value":{"int64Value":"3"}},"ast":"size(\n {\n 1^#*expr.Constant_Int64Value#:\"one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:\"three\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n {\n 1~int:\"one\"~string,\n 2~int:\"two\"~string,\n 3~int:\"three\"~string\n }~map(int, string)\n)~int^size_map","type":"int"}]}]},{"name":"logic","suites":[{"name":"conditional","tests":[{"original":{"name":"true_case","expr":"true ? 1 : 2","value":{"int64Value":"1"}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"false_case","expr":"false ? 'foo' : 'bar'","value":{"stringValue":"bar"}},"ast":"_?_:_(\n false^#*expr.Constant_BoolValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n false~bool,\n \"foo\"~string,\n \"bar\"~string\n)~string^conditional","type":"string"},{"original":{"name":"error_case","expr":"2 / 0 \u003e 4 ? 'baz' : 'quux'","evalError":{"errors":[{"message":"division by zero"}]}},"ast":"_?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"baz\"^#*expr.Constant_StringValue#,\n \"quux\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n \"baz\"~string,\n \"quux\"~string\n)~string^conditional","type":"string"},{"original":{"name":"mixed_type","expr":"true ? 'cows' : 17","disableCheck":true,"value":{"stringValue":"cows"}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n \"cows\"^#*expr.Constant_StringValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:6: found no matching overload for '_?_:_' applied to '(bool, string, int)'\n | true ? 'cows' : 17\n | .....^"},{"original":{"name":"bad_type","expr":"'cows' ? false : 17","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_?_:_(\n \"cows\"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:8: found no matching overload for '_?_:_' applied to '(string, bool, int)'\n | 'cows' ? false : 17\n | .......^"}]},{"name":"AND","tests":[{"original":{"name":"all_true","expr":"true \u0026\u0026 true","value":{"boolValue":true}},"ast":"_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n true~bool,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"all_false","expr":"false \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n false~bool,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"false_left","expr":"false \u0026\u0026 true","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n false~bool,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"false_right","expr":"true \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n true~bool,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"short_circuit_type_left","expr":"false \u0026\u0026 32","disableCheck":true,"value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: expected type 'bool' but found 'int'\n | false \u0026\u0026 32\n | .........^"},{"original":{"name":"short_circuit_type_right","expr":"'horses' \u0026\u0026 false","disableCheck":true,"value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n \"horses\"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' \u0026\u0026 false\n | ^"},{"original":{"name":"short_circuit_error_left","expr":"false \u0026\u0026 (2 / 0 \u003e 3 ? false : true)","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n false~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_and","type":"bool"},{"original":{"name":"short_circuit_error_right","expr":"(2 / 0 \u003e 3 ? false : true) \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n false~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"error_right","expr":"true \u0026\u0026 1/0 != 0","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n true~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_and","type":"bool"},{"original":{"name":"error_left","expr":"1/0 != 0 \u0026\u0026 true","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_\u0026\u0026_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n true~bool\n)~bool^logical_and","type":"bool"},{"original":{"name":"no_overload","expr":"'less filling' \u0026\u0026 'tastes great'","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_\u0026\u0026_(\n \"less filling\"^#*expr.Constant_StringValue#,\n \"tastes great\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ..................^"}]},{"name":"OR","tests":[{"original":{"name":"all_true","expr":"true || true","value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n true~bool,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"all_false","expr":"false || false","value":{"boolValue":false}},"ast":"_||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n false~bool,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"false_left","expr":"false || true","value":{"boolValue":true}},"ast":"_||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n false~bool,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"false_right","expr":"true || false","value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n true~bool,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"short_circuit_type_left","expr":"true || 32","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: expected type 'bool' but found 'int'\n | true || 32\n | ........^"},{"original":{"name":"short_circuit_type_right","expr":"'horses' || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n \"horses\"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' || true\n | ^"},{"original":{"name":"short_circuit_error_left","expr":"true || (2 / 0 \u003e 3 ? false : true)","value":{"boolValue":true}},"ast":"_||_(\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n true~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_or","type":"bool"},{"original":{"name":"short_circuit_error_right","expr":"(2 / 0 \u003e 3 ? false : true) || true","value":{"boolValue":true}},"ast":"_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n true~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"error_right","expr":"false || 1/0 != 0","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_||_(\n false^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n false~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_or","type":"bool"},{"original":{"name":"error_left","expr":"1/0 != 0 || false","evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_||_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n false~bool\n)~bool^logical_or","type":"bool"},{"original":{"name":"no_overload","expr":"'less filling' || 'tastes great'","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"_||_(\n \"less filling\"^#*expr.Constant_StringValue#,\n \"tastes great\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ..................^"}]},{"name":"NOT","tests":[{"original":{"name":"not_true","expr":"!true","value":{"boolValue":false}},"ast":"!_(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n true~bool\n)~bool^logical_not","type":"bool"},{"original":{"name":"not_false","expr":"!false","value":{"boolValue":true}},"ast":"!_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n false~bool\n)~bool^logical_not","type":"bool"},{"original":{"name":"no_overload","expr":"!0","disableCheck":true,"evalError":{"errors":[{"message":"no matching overload"}]}},"ast":"!_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: found no matching overload for '!_' applied to '(int)'\n | !0\n | ^"}]}]},{"name":"macros","suites":[{"name":"exists","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].exists(e, e \u003e 0)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].exists(e, e == 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].exists(e, e \u003e 3)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_shortcircuit","description":"Exists filter is true for the last element.","expr":"[1, 'foo', 3].exists(e, e != '1')","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n e^#*expr.Expr_IdentExpr#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n e~dyn^e,\n \"1\"~string\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_exhaustive","description":"Exists filter is never true, but heterogenous equality ensure the result is false.","expr":"[1, 'foo', 3].exists(e, e == '10')","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n \"10\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n \"10\"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_exists_error","expr":"[1, 2, 3].exists(e, e / 0 == 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_empty","expr":"[].exists(e, e == 2)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.exists(k, k == 'key2')","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"~string:1~int,\n \"key2\"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n \"key2\"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"not_map_key","expr":"!{'key1':1, 'key2':2}.exists(k, k == 'key3')","value":{"boolValue":true}},"ast":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key3\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"~string:1~int,\n \"key2\"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n \"key3\"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not","type":"bool"},{"original":{"name":"map_key_type_shortcircuit","description":"Exists filter is true for the second key","expr":"{'key':1, 1:21}.exists(k, k != 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"~string:1~int,\n 1~int:21~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n k~dyn^k,\n 2~int\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"map_key_type_exhaustive","description":"Exists filter is never true, but heterogeneous equality ensures the result is false.","expr":"!{'key':1, 1:42}.exists(k, k == 2)","value":{"boolValue":true}},"ast":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n \"key\"~string:1~int,\n 1~int:42~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~dyn^k,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not","type":"bool"}]},{"name":"all","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].all(e, e \u003e 0)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].all(e, e == 2)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].all(e, e == 17)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 17~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_shortcircuit","expr":"[1, 'foo', 3].all(e, e == 1)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_type_exhaustive","expr":"[1, 'foo', 3].all(e, e % 2 == 1)","evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n \"foo\"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _%_(\n e~dyn^e,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_error_shortcircuit","expr":"[1, 2, 3].all(e, 6 / (2 - e) == 6)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n e^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _/_(\n 6~int,\n _-_(\n 2~int,\n e~int^e\n )~int^subtract_int64\n )~int^divide_int64,\n 6~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_elem_error_exhaustive","expr":"[1, 2, 3].all(e, e / 0 != 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _!=_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^not_equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"list_empty","expr":"[].all(e, e \u003e 0)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.all(k, k == 'key2')","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n k,\n // Target\n {\n \"key1\"~string:1~int,\n \"key2\"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n k~string^k,\n \"key2\"~string\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"}]},{"name":"exists_one","tests":[{"original":{"name":"list_empty","expr":"[].exists_one(a, a == 7)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n a,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n a,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_one_true","expr":"[7].exists_one(a, a == 7)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 7^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 7~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_one_false","expr":"[8].exists_one(a, a == 7)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n a,\n // Target\n [\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_none","expr":"[1, 2, 3].exists_one(x, x \u003e 20)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n x^#*expr.Expr_IdentExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n x~int^x,\n 20~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_one","expr":"[6, 7, 8].exists_one(foo, foo % 5 == 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6~int,\n 7~int,\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_many","expr":"[0, 1, 2, 3, 4].exists_one(n, n % 2 == 1)","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_all","expr":"['foal', 'foo', 'four'].exists_one(n, n.startsWith('fo'))","value":{"boolValue":false}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n \"foal\"^#*expr.Constant_StringValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n \"four\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n n^#*expr.Expr_IdentExpr#.startsWith(\n \"fo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n \"foal\"~string,\n \"foo\"~string,\n \"four\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n n~string^n.startsWith(\n \"fo\"~string\n )~bool^starts_with_string,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"list_no_shortcircuit","description":"Errors invalidate everything, even if already false.","expr":"[3, 2, 1, 0].exists_one(n, 12 / n \u003e 1)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 1~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"},{"original":{"name":"map_one","expr":"{6: 'six', 7: 'seven', 8: 'eight'}.exists_one(foo, foo % 5 == 2)","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6^#*expr.Constant_Int64Value#:\"six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:\"seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:\"eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6~int:\"six\"~string,\n 7~int:\"seven\"~string,\n 8~int:\"eight\"~string\n }~map(int, string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool","type":"bool"}]},{"name":"map","tests":[{"original":{"name":"list_empty","expr":"[].map(n, n / 2)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_one","expr":"[3].map(n, n * n)","value":{"listValue":{"values":[{"int64Value":"9"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _*_(\n n^#*expr.Expr_IdentExpr#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _*_(\n n~int^n,\n n~int^n\n )~int^multiply_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_many","expr":"[2, 4, 6].map(n, n / 2)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 4~int,\n 6~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_error","expr":"[2, 1, 0].map(n, 4 / n)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n 4^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n 4~int,\n n~int^n\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"map_extract_keys","expr":"{'John': 'smart'}.map(key, key) == ['John']","value":{"boolValue":true}},"ast":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"^#*expr.Constant_StringValue#:\"smart\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n \"John\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"~string:\"smart\"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n // Result\n @result~list(string)^@result)~list(string),\n [\n \"John\"~string\n ]~list(string)\n)~bool^equals","type":"bool"}]},{"name":"filter","tests":[{"original":{"name":"list_empty","expr":"[].filter(n, n % 2 == 0)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 0~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_one_true","expr":"[2].filter(n, n == 2)","value":{"listValue":{"values":[{"int64Value":"2"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n n~int^n,\n 2~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_one_false","expr":"[1].filter(n, n \u003e 3)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_none","expr":"[1, 2, 3].filter(e, e \u003e 3)","value":{"listValue":{}}},"ast":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n e^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n e~int^e\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_some","expr":"[0, 1, 2, 3, 4].filter(x, x % 2 == 1)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"3"}]}}},"ast":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n x,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x~int^x,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n x~int^x\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_all","expr":"[1, 2, 3].filter(n, n \u003e 0)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"2"},{"int64Value":"3"}]}}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 0~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"list_no_shortcircuit","expr":"[3, 2, 1, 0].filter(n, 12 / n \u003e 4)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"map_filter_keys","expr":"{'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}.filter(key, key == 'Ringo') == ['Ringo']","value":{"boolValue":true}},"ast":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"^#*expr.Constant_StringValue#:\"smart\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Paul\"^#*expr.Constant_StringValue#:\"cute\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"George\"^#*expr.Constant_StringValue#:\"quiet\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"Ringo\"^#*expr.Constant_StringValue#:\"funny\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n key^#*expr.Expr_IdentExpr#,\n \"Ringo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n \"Ringo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n \"John\"~string:\"smart\"~string,\n \"Paul\"~string:\"cute\"~string,\n \"George\"~string:\"quiet\"~string,\n \"Ringo\"~string:\"funny\"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n key~string^key,\n \"Ringo\"~string\n )~bool^equals,\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string),\n [\n \"Ringo\"~string\n ]~list(string)\n)~bool^equals","type":"bool"}]},{"name":"nested","tests":[{"original":{"name":"filter_all","expr":"['signer'].filter(signer, ['artifact'].all(artifact, true))","value":{"listValue":{"values":[{"stringValue":"signer"}]}}},"ast":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n signer^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool,\n _+_(\n @result~list(string)^@result,\n [\n signer~string^signer\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string)","type":"list(string)"},{"original":{"name":"all_all","expr":"['signer'].all(signer, ['artifact'].all(artifact, true))","value":{"boolValue":true}},"ast":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n signer,\n // Target\n [\n \"signer\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n \"artifact\"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool","type":"bool"}]}]},{"name":"macros2","suites":[{"name":"exists","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................................^"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................................^"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................................^"},{"original":{"name":"list_elem_type_shortcircuit","expr":"[1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................................^"},{"original":{"name":"list_elem_type_exhaustive","expr":"[1, 'foo', 3].exists(i, v, i == 3 || v == '10')","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"10\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................................^"},{"original":{"name":"list_elem_exists_error","expr":"[1, 2, 3].exists(i, v, v / i == 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ...........................^"},{"original":{"name":"list_empty","expr":"[].exists(i, v, i == 0 || v == 2)","value":{"boolValue":false}},"ast":"[]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: undeclared reference to 'exists' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .........^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........................^"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)","value":{"boolValue":true}},"ast":"{\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: undeclared reference to 'exists' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..................................^\nERROR: \u003cinput\u003e:1:50: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .................................................^"},{"original":{"name":"not_map_key","expr":"!{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)","value":{"boolValue":true}},"ast":"!_(\n {\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key3\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:29: undeclared reference to 'exists' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ............................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ................................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ...................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ..................................................^"},{"original":{"name":"map_key_type_shortcircuit","expr":"{'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)","value":{"boolValue":true}},"ast":"{\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:23: undeclared reference to 'exists' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .............................^\nERROR: \u003cinput\u003e:1:40: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................................^"},{"original":{"name":"map_key_type_exhaustive","expr":"!{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)","value":{"boolValue":true}},"ast":"!_(\n {\n \"key\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 43^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'exists' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................................^"}]},{"name":"all","tests":[{"original":{"name":"list_elem_all_true","expr":"[1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)","value":{"boolValue":true}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............................^"},{"original":{"name":"list_elem_some_true","expr":"[1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............................^"},{"original":{"name":"list_elem_none_true","expr":"[1, 2, 3].all(i, v, i == 3 || v == 4)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............................^"},{"original":{"name":"list_elem_type_shortcircuit","expr":"[1, 'foo', 3].all(i, v, i == 0 || v == 1)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................................^"},{"original":{"name":"list_elem_type_exhaustive","expr":"[0, 'foo', 3].all(i, v, v % 2 == i)","value":{"boolValue":false}},"ast":"[\n 0^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................................^"},{"original":{"name":"list_elem_type_error_exhaustive","expr":"[0, 'foo', 5].all(i, v, v % 3 == i)","evalError":{"errors":[{"message":"no_such_overload"}]}},"ast":"[\n 0^#*expr.Constant_Int64Value#,\n \"foo\"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................................^"},{"original":{"name":"list_elem_error_shortcircuit","expr":"[1, 2, 3].all(i, v, 6 / (2 - v) == i)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ...................................^"},{"original":{"name":"list_elem_error_exhaustive","expr":"[1, 2, 3].all(i, v, v / i != 17)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ........................^"},{"original":{"name":"list_empty","expr":"[].all(i, v, i \u003e -1 || v \u003e 0)","value":{"boolValue":true}},"ast":"[]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:7: undeclared reference to 'all' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ......^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......................^"},{"original":{"name":"map_key","expr":"{'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)","value":{"boolValue":false}},"ast":"{\n \"key1\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.all(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"key2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:25: undeclared reference to 'all' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ........................^\nERROR: \u003cinput\u003e:1:26: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..............................................^"}]},{"name":"existsOne","tests":[{"original":{"name":"list_empty","expr":"[].existsOne(i, v, i == 3 || v == 7)","value":{"boolValue":false}},"ast":"[]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: undeclared reference to 'existsOne' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ............^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ...................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............................^"},{"original":{"name":"list_one_true","expr":"[7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)","value":{"boolValue":true}},"ast":"[\n 7^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^"},{"original":{"name":"list_one_false","expr":"[8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)","value":{"boolValue":false}},"ast":"[\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^"},{"original":{"name":"list_none","expr":"[1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)","value":{"boolValue":false}},"ast":"[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................................^"},{"original":{"name":"list_one","expr":"[5, 7, 8].existsOne(i, v, v % 5 == i)","value":{"boolValue":true}},"ast":"[\n 5^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................................^"},{"original":{"name":"list_many","expr":"[0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)","value":{"boolValue":false}},"ast":"[\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:26: undeclared reference to 'existsOne' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................................^"},{"original":{"name":"list_all","expr":"['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))","value":{"boolValue":false}},"ast":"[\n \"foal\"^#*expr.Constant_StringValue#,\n \"foo\"^#*expr.Constant_StringValue#,\n \"four\"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#.startsWith(\n \"fo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:34: undeclared reference to 'existsOne' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .................................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .....................................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ........................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................................^"},{"original":{"name":"list_no_shortcircuit","expr":"[3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:23: undeclared reference to 'existsOne' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .............................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .................................^"},{"original":{"name":"map_one","expr":"{6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')","value":{"boolValue":true}},"ast":"{\n 6^#*expr.Constant_Int64Value#:\"six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:\"seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:\"eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.existsOne(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n _%_(\n k^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"seven\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:45: undeclared reference to 'existsOne' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ............................................^\nERROR: \u003cinput\u003e:1:46: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .............................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ................................................^\nERROR: \u003cinput\u003e:1:52: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ...................................................^\nERROR: \u003cinput\u003e:1:66: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .................................................................^"}]},{"name":"transformList","tests":[{"original":{"name":"empty","expr":"[].transformList(i, v, i / v)","value":{"listValue":{}}},"ast":"[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ...........................^"},{"original":{"name":"empty_filter","expr":"[].transformList(i, v, i \u003e v, i / v)","value":{"listValue":{}}},"ast":"[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..................................^"},{"original":{"name":"one","expr":"[3].transformList(i, v, v * v + i)","value":{"listValue":{"values":[{"int64Value":"9"}]}}},"ast":"[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ................................^"},{"original":{"name":"one_filter","expr":"[3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)","value":{"listValue":{"values":[{"int64Value":"9"}]}}},"ast":"[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................^\nERROR: \u003cinput\u003e:1:43: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..........................................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................................^"},{"original":{"name":"many","expr":"[2, 4, 6].transformList(i, v, v / 2 + i)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"3"},{"int64Value":"5"}]}}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ......................................^"},{"original":{"name":"many_filter","expr":"[2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)","value":{"listValue":{"values":[{"int64Value":"1"},{"int64Value":"5"}]}}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ................................................^\nERROR: \u003cinput\u003e:1:57: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................................^"},{"original":{"name":"error","expr":"[2, 1, 0].transformList(i, v, v / i)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..................................^"},{"original":{"name":"error_filter","expr":"[2, 1, 0].transformList(i, v, v / i \u003e 0, v)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .........................................^"}]},{"name":"transformMap","tests":[{"original":{"name":"empty","expr":"{}.transformMap(k, v, k + v)","value":{"mapValue":{}}},"ast":"{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ..........................^"},{"original":{"name":"empty_filter","expr":"{}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)","value":{"mapValue":{}}},"ast":"{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"foo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"bar\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:37: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:53: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................................^"},{"original":{"name":"one","expr":"{'foo': 'bar'}.transformMap(k, v, k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ......................................^"},{"original":{"name":"one_filter","expr":"{'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"foo\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n \"bar\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:65: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................................^"},{"original":{"name":"many","expr":"{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}},{"key":{"stringValue":"baz"},"value":{"stringValue":"bazbux"}},{"key":{"stringValue":"hello"},"value":{"stringValue":"helloworld"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:\"bux\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"hello\"^#*expr.Constant_StringValue#:\"world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:71: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ......................................................................^"},{"original":{"name":"many_filter","expr":"{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)","value":{"mapValue":{"entries":[{"key":{"stringValue":"foo"},"value":{"stringValue":"foobar"}},{"key":{"stringValue":"hello"},"value":{"stringValue":"helloworld"}}]}}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:\"bar\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:\"bux\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"hello\"^#*expr.Constant_StringValue#:\"world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n \"baz\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n \"bux\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:81: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................^\nERROR: \u003cinput\u003e:1:93: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................................................^\nERROR: \u003cinput\u003e:1:97: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................................^"},{"original":{"name":"error","expr":"{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"bar\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:55: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ......................................................^"},{"original":{"name":"error_filter","expr":"{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)","evalError":{"errors":[{"message":"divide by zero"}]}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"bar\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"baz\"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n \"baz\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ..................................................^\nERROR: \u003cinput\u003e:1:69: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ....................................................................^\nERROR: \u003cinput\u003e:1:77: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................................................^"}]}]},{"name":"math_ext","suites":[{"name":"greatest_int_result","tests":[{"original":{"name":"unary_negative","expr":"math.greatest(-5)","value":{"int64Value":"-5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -5~int\n)~int^math_@max_int","type":"int"},{"original":{"name":"unary_positive","expr":"math.greatest(5)","value":{"int64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5~int\n)~int^math_@max_int","type":"int"},{"original":{"name":"binary_same_args","expr":"math.greatest(1, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n 1~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_with_decimal","expr":"math.greatest(1, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~int,\n 1~double\n )~dyn^math_@max_int_double,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.greatest(1, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~int,\n 1u~uint\n )~dyn^math_@max_int_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_greater","expr":"math.greatest(3, -3)","value":{"int64Value":"3"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 3^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 3~int,\n -3~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_second_arg_greater","expr":"math.greatest(-7, 5)","value":{"int64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -7^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -7~int,\n 5~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_max","expr":"math.greatest(9223372036854775807, 1)","value":{"int64Value":"9223372036854775807"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 9223372036854775807~int,\n 1~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_max","expr":"math.greatest(1, 9223372036854775807)","value":{"int64Value":"9223372036854775807"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n 9223372036854775807~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_min","expr":"math.greatest(-9223372036854775808, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -9223372036854775808~int,\n 1~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_min","expr":"math.greatest(1, -9223372036854775808)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n -9223372036854775808~int\n)~int^math_@max_int_int","type":"int"},{"original":{"name":"ternary_same_args","expr":"math.greatest(1, 1, 1) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@max_list_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.greatest(1, 1.0, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.greatest(1, 1u, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_greatest","expr":"math.greatest(10, 1, 3) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 10~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_greatest","expr":"math.greatest(1, 3, 10) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~int,\n 3~int,\n 10~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.greatest(-1, -2, -3) == -1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_max","expr":"math.greatest(9223372036854775807, 1, 5) == 9223372036854775807"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@max_list_int,\n 9223372036854775807~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_min","expr":"math.greatest(-9223372036854775807, -1, -5) == -1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775807^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -9223372036854775807~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.greatest(5.4, 10, 3u, -5.0, 9223372036854775807) == 9223372036854775807"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 9223372036854775807~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.greatest([5.4, 10, 3u, -5.0, 3.5]) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.greatest([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals","type":"bool"}]},{"name":"greatest_double_result","tests":[{"original":{"name":"unary_negative","expr":"math.greatest(-5.0)","value":{"doubleValue":-5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -5~double\n)~double^math_@max_double","type":"double"},{"original":{"name":"unary_positive","expr":"math.greatest(5.0)","value":{"doubleValue":5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5~double\n)~double^math_@max_double","type":"double"},{"original":{"name":"binary_same_args","expr":"math.greatest(1.0, 1.0)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~double,\n 1~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_with_int","expr":"math.greatest(1.0, 1) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~double,\n 1~int\n )~dyn^math_@max_double_int,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.greatest(1.0, 1u) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1~double,\n 1u~uint\n )~dyn^math_@max_double_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_greater","expr":"math.greatest(5.0, -7.0)","value":{"doubleValue":5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#,\n -7^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5~double,\n -7~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_second_arg_greater","expr":"math.greatest(-3.0, 3.0)","value":{"doubleValue":3}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -3~double,\n 3~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_first_arg_double_max","expr":"math.greatest(1.797693e308, 1)","value":{"doubleValue":1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1.797693e+308~double,\n 1~int\n)~dyn^math_@max_double_int","type":"dyn"},{"original":{"name":"binary_second_arg_double_max","expr":"math.greatest(1, 1.797693e308)","value":{"doubleValue":1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1~int,\n 1.797693e+308~double\n)~dyn^math_@max_int_double","type":"dyn"},{"original":{"name":"binary_first_arg_double_min","expr":"math.greatest(-1.797693e308, 1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"binary_second_arg_double_min","expr":"math.greatest(1.5, -1.797693e308)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@max_double_double","type":"double"},{"original":{"name":"ternary_same_args","expr":"math.greatest(1.0, 1.0, 1.0) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~double,\n 1~double,\n 1~double\n ]~list(double)\n )~double^math_@max_list_double,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.greatest(1.0, 1, 1) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.greatest(1.0, 1u, 1u) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_greatest","expr":"math.greatest(10.5, 1.5, 3.5) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 10.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_greatest","expr":"math.greatest(1.5, 3.5, 10.5) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1.5~double,\n 3.5~double,\n 10.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.greatest(-1.5, -2.5, -3.5) == -1.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n -1.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_max","expr":"math.greatest(1.797693e308, 1, 5) == 1.797693e308"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_min","expr":"math.greatest(-1.797693e308, -1, -5) == -1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.greatest(5.4, 10, 3u, -5.0, 1.797693e308) == 1.797693e308"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.greatest([5.4, 10.5, 3u, -5.0, 3.5]) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.greatest([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals","type":"bool"}]},{"name":"greatest_uint_result","tests":[{"original":{"name":"unary","expr":"math.greatest(5u)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5u~uint\n)~uint^math_@max_uint","type":"uint"},{"original":{"name":"binary_same_args","expr":"math.greatest(1u, 1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint","type":"uint"},{"original":{"name":"binary_with_decimal","expr":"math.greatest(1u, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1u~uint,\n 1~double\n )~dyn^math_@max_uint_double,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_int","expr":"math.greatest(1u, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n 1u~uint,\n 1~int\n )~dyn^math_@max_uint_int,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_greater","expr":"math.greatest(5u, -7)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 5u~uint,\n -7~int\n)~dyn^math_@max_uint_int","type":"dyn"},{"original":{"name":"binary_second_arg_greater","expr":"math.greatest(-3, 3u)","value":{"uint64Value":"3"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n -3~int,\n 3u~uint\n)~dyn^math_@max_int_uint","type":"dyn"},{"original":{"name":"binary_first_arg_uint_max","expr":"math.greatest(18446744073709551615u, 1u)","value":{"uint64Value":"18446744073709551615"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint","type":"uint"},{"original":{"name":"binary_second_arg_uint_max","expr":"math.greatest(1u, 18446744073709551615u)","value":{"uint64Value":"18446744073709551615"}},"ast":"math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@max(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@max_uint_uint","type":"uint"},{"original":{"name":"ternary_same_args","expr":"math.greatest(1u, 1u, 1u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.greatest(1u, 1.0, 1.0) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.greatest(1u, 1, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_greatest","expr":"math.greatest(10u, 1u, 3u) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 10u~uint,\n 1u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_greatest","expr":"math.greatest(1u, 3u, 10u) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 1u~uint,\n 3u~uint,\n 10u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_max","expr":"math.greatest(18446744073709551615u, 1u, 5u) == 18446744073709551615u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.greatest(5.4, 10, 3u, -5.0, 18446744073709551615u) == 18446744073709551615u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.greatest([5.4, 10u, 3u, -5.0, 3.5]) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.greatest([dyn(5.4), dyn(10u), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals","type":"bool"}]},{"name":"least_int_result","tests":[{"original":{"name":"unary_negative","expr":"math.least(-5)","value":{"int64Value":"-5"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -5~int\n)~int^math_@min_int","type":"int"},{"original":{"name":"unary_positive","expr":"math.least(5)","value":{"int64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5~int\n)~int^math_@min_int","type":"int"},{"original":{"name":"binary_same_args","expr":"math.least(1, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1~int,\n 1~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_with_decimal","expr":"math.least(1, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~int,\n 1~double\n )~dyn^math_@min_int_double,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.least(1, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_least","expr":"math.least(-3, 3)","value":{"int64Value":"-3"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -3~int,\n 3~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_second_arg_least","expr":"math.least(5, -7)","value":{"int64Value":"-7"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5~int,\n -7~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_max","expr":"math.least(9223372036854775807, 1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 9223372036854775807~int,\n 1~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_max","expr":"math.least(1, 9223372036854775807)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1~int,\n 9223372036854775807~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_first_arg_int_min","expr":"math.least(-9223372036854775808, 1)","value":{"int64Value":"-9223372036854775808"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -9223372036854775808~int,\n 1~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"binary_second_arg_int_min","expr":"math.least(1, -9223372036854775808)","value":{"int64Value":"-9223372036854775808"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1~int,\n -9223372036854775808~int\n)~int^math_@min_int_int","type":"int"},{"original":{"name":"ternary_same_args","expr":"math.least(1, 1, 1) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.least(1, 1.0, 1.0) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.least(1, 1u, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_least","expr":"math.least(0, 1, 3) == 0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 0~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_least","expr":"math.least(1, 3, 0) == 0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~int,\n 3~int,\n 0~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.least(-1, -2, -3) == -3"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@min_list_int,\n -3~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_max","expr":"math.least(9223372036854775807, 1, 5) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_int_min","expr":"math.least(-9223372036854775808, -1, -5) == -9223372036854775808"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -9223372036854775808~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@min_list_int,\n -9223372036854775808~int\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.least(5.4, 10, 3u, -5.0, 9223372036854775807) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.least([5.4, 10, 3u, -5.0, 3.5]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.least([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"}]},{"name":"least_double_result","tests":[{"original":{"name":"unary_negative","expr":"math.least(-5.5)","value":{"doubleValue":-5.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -5.5~double\n)~double^math_@min_double","type":"double"},{"original":{"name":"unary_positive","expr":"math.least(5.5)","value":{"doubleValue":5.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5.5~double\n)~double^math_@min_double","type":"double"},{"original":{"name":"binary_same_args","expr":"math.least(1.5, 1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.5~double,\n 1.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_with_int","expr":"math.least(1.0, 1) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~double,\n 1~int\n )~dyn^math_@min_double_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_uint","expr":"math.least(1, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_least","expr":"math.least(-3.5, 3.5)","value":{"doubleValue":-3.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -3.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -3.5~double,\n 3.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_second_arg_least","expr":"math.least(5.5, -7.5)","value":{"doubleValue":-7.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#,\n -7.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5.5~double,\n -7.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_first_arg_double_max","expr":"math.least(1.797693e308, 1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_second_arg_double_max","expr":"math.least(1.5, 1.797693e308)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.5~double,\n 1.797693e+308~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_first_arg_double_min","expr":"math.least(-1.797693e308, 1.5)","value":{"doubleValue":-1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"binary_second_arg_double_min","expr":"math.least(1.5, -1.797693e308)","value":{"doubleValue":-1.797693e+308}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@min_double_double","type":"double"},{"original":{"name":"ternary_same_args","expr":"math.least(1.5, 1.5, 1.5) == 1.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1.5~double,\n 1.5~double,\n 1.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 1.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.least(1.0, 1, 1) == 1.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_uint","expr":"math.least(1.0, 1u, 1u) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_least","expr":"math.least(0.5, 1.5, 3.5) == 0.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 0.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_least","expr":"math.least(1.5, 3.5, 0.5) == 0.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 0.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1.5~double,\n 3.5~double,\n 0.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_negatives","expr":"math.least(-1.5, -2.5, -3.5) == -3.5"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n -3.5~double\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_max","expr":"math.least(1.797693e308, 1, 5) == 1"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_double_min","expr":"math.least(-1.797693e308, -1, -5) == -1.797693e308"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -1.797693e+308~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.least(5.4, 10, 3u, -5.0, 1.797693e308) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.least([5.4, 10.5, 3u, -5.0, 3.5]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.least([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals","type":"bool"}]},{"name":"least_uint_result","tests":[{"original":{"name":"unary","expr":"math.least(5u)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5u~uint\n)~uint^math_@min_uint","type":"uint"},{"original":{"name":"binary_same_args","expr":"math.least(1u, 1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_with_decimal","expr":"math.least(1u, 1.0) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1u~uint,\n 1~double\n )~dyn^math_@min_uint_double,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"binary_with_int","expr":"math.least(1u, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n 1u~uint,\n 1~int\n )~dyn^math_@min_uint_int,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"binary_first_arg_least","expr":"math.least(1u, 3u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1u~uint,\n 3u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_second_arg_least","expr":"math.least(5u, 2u)","value":{"uint64Value":"2"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 5u~uint,\n 2u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_first_arg_uint_max","expr":"math.least(18446744073709551615u, 1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"binary_second_arg_uint_max","expr":"math.least(1u, 18446744073709551615u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.@min(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@min_uint_uint","type":"uint"},{"original":{"name":"ternary_same_args","expr":"math.least(1u, 1u, 1u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_decimal","expr":"math.least(1u, 1.0, 1.0) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_with_int","expr":"math.least(1u, 1, 1) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_first_arg_least","expr":"math.least(1u, 10u, 3u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 1u~uint,\n 10u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_third_arg_least","expr":"math.least(10u, 3u, 1u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 10u~uint,\n 3u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_uint_max","expr":"math.least(18446744073709551615u, 1u, 5u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed","expr":"math.least(5.4, 10, 3u, 1u, 18446744073709551615u) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n 1u~uint,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_array","expr":"math.least([5.4, 10u, 3u, 1u, 3.5]) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n 1u~uint,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"},{"original":{"name":"quaternary_mixed_dyn_array","expr":"math.least([dyn(5.4), dyn(10u), dyn(3u), dyn(1u), dyn(3.5)]) == 1u"},"ast":"_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals","type":"bool"}]},{"name":"ceil","tests":[{"original":{"name":"negative","expr":"math.ceil(-1.2)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.ceil(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.ceil(\n -1.2~double\n)~double^math_ceil_double","type":"double"},{"original":{"name":"positive","expr":"math.ceil(1.2)","value":{"doubleValue":2}},"ast":"math^#*expr.Expr_IdentExpr#.ceil(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.ceil(\n 1.2~double\n)~double^math_ceil_double","type":"double"},{"original":{"name":"dyn_error","expr":"math.ceil(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.ceil(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.ceil(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_ceil_double","type":"double"}]},{"name":"floor","tests":[{"original":{"name":"negative","expr":"math.floor(-1.2)","value":{"doubleValue":-2}},"ast":"math^#*expr.Expr_IdentExpr#.floor(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.floor(\n -1.2~double\n)~double^math_floor_double","type":"double"},{"original":{"name":"positive","expr":"math.floor(1.2)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.floor(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.floor(\n 1.2~double\n)~double^math_floor_double","type":"double"},{"original":{"name":"dyn_error","expr":"math.floor(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.floor(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.floor(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_floor_double","type":"double"}]},{"name":"round","tests":[{"original":{"name":"negative_down","expr":"math.round(-1.6)","value":{"doubleValue":-2}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n -1.6^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n -1.6~double\n)~double^math_round_double","type":"double"},{"original":{"name":"negative_up","expr":"math.round(-1.4)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n -1.4^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n -1.4~double\n)~double^math_round_double","type":"double"},{"original":{"name":"negative_mid","expr":"math.round(-1.5)","value":{"doubleValue":-2}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n -1.5~double\n)~double^math_round_double","type":"double"},{"original":{"name":"positive_down","expr":"math.round(1.2)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n 1.2~double\n)~double^math_round_double","type":"double"},{"original":{"name":"positive_up","expr":"math.round(1.5)","value":{"doubleValue":2}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n 1.5~double\n)~double^math_round_double","type":"double"},{"original":{"name":"nan","expr":"math.isNaN(math.round(0.0/0.0))"},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.round(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n math.round(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_round_double\n)~bool^math_isNaN_double","type":"bool"},{"original":{"name":"dyn_error","expr":"math.round(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.round(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.round(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_round_double","type":"double"}]},{"name":"trunc","tests":[{"original":{"name":"negative","expr":"math.trunc(-1.2)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.trunc(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.trunc(\n -1.2~double\n)~double^math_trunc_double","type":"double"},{"original":{"name":"positive","expr":"math.trunc(1.2)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.trunc(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.trunc(\n 1.2~double\n)~double^math_trunc_double","type":"double"},{"original":{"name":"nan","expr":"math.isNaN(math.trunc(0.0/0.0))"},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.trunc(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n math.trunc(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_trunc_double\n)~bool^math_isNaN_double","type":"bool"},{"original":{"name":"dyn_error","expr":"math.trunc(dyn(1))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.trunc(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.trunc(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_trunc_double","type":"double"}]},{"name":"abs","tests":[{"original":{"name":"uint","expr":"math.abs(1u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n 1u~uint\n)~uint^math_abs_uint","type":"uint"},{"original":{"name":"positive_int","expr":"math.abs(1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n 1~int\n)~int^math_abs_int","type":"int"},{"original":{"name":"negative_int","expr":"math.abs(-11)","value":{"int64Value":"11"}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n -11~int\n)~int^math_abs_int","type":"int"},{"original":{"name":"positive_double","expr":"math.abs(1.5)","value":{"doubleValue":1.5}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n 1.5~double\n)~double^math_abs_double","type":"double"},{"original":{"name":"negative_double","expr":"math.abs(-11.5)","value":{"doubleValue":11.5}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n -11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n -11.5~double\n)~double^math_abs_double","type":"double"},{"original":{"name":"int_overflow","expr":"math.abs(-9223372036854775808)","evalError":{"errors":[{"message":"overflow"}]}},"ast":"math^#*expr.Expr_IdentExpr#.abs(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.abs(\n -9223372036854775808~int\n)~int^math_abs_int","type":"int"}]},{"name":"sign","tests":[{"original":{"name":"positive_uint","expr":"math.sign(100u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 100u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 100u~uint\n)~uint^math_sign_uint","type":"uint"},{"original":{"name":"zero_uint","expr":"math.sign(0u)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 0u~uint\n)~uint^math_sign_uint","type":"uint"},{"original":{"name":"positive_int","expr":"math.sign(100)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 100^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 100~int\n)~int^math_sign_int","type":"int"},{"original":{"name":"negative_int","expr":"math.sign(-11)","value":{"int64Value":"-1"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n -11~int\n)~int^math_sign_int","type":"int"},{"original":{"name":"zero_int","expr":"math.sign(0)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 0~int\n)~int^math_sign_int","type":"int"},{"original":{"name":"positive_double","expr":"math.sign(100.5)","value":{"doubleValue":1}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 100.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 100.5~double\n)~double^math_sign_double","type":"double"},{"original":{"name":"negative_double","expr":"math.sign(-32.0)","value":{"doubleValue":-1}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n -32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n -32~double\n)~double^math_sign_double","type":"double"},{"original":{"name":"zero_double","expr":"math.sign(0.0)","value":{"doubleValue":0}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n 0~double\n)~double^math_sign_double","type":"double"},{"original":{"name":"dyn_error","expr":"math.sign(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.sign(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.sign(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~dyn^math_sign_double|math_sign_int|math_sign_uint","type":"dyn"}]},{"name":"isNaN","tests":[{"original":{"name":"true","expr":"math.isNaN(0.0/0.0)"},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^math_isNaN_double","type":"bool"},{"original":{"name":"false","expr":"!math.isNaN(1.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isNaN(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isNaN_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"dyn_error","expr":"math.isNaN(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.isNaN(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isNaN(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isNaN_double","type":"bool"}]},{"name":"isInf","tests":[{"original":{"name":"true","expr":"math.isInf(1.0/0.0)"},"ast":"math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isInf(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n)~bool^math_isInf_double","type":"bool"},{"original":{"name":"false","expr":"!math.isInf(0.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isInf(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isInf_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"dyn_error","expr":"math.isInf(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.isInf(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isInf(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isInf_double","type":"bool"}]},{"name":"isFinite","tests":[{"original":{"name":"true","expr":"math.isFinite(1.0/1.5)"},"ast":"math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isFinite(\n _/_(\n 1~double,\n 1.5~double\n )~double^divide_double\n)~bool^math_isFinite_double","type":"bool"},{"original":{"name":"false_nan","expr":"!math.isFinite(0.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isFinite(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"false_inf","expr":"!math.isFinite(-1.0/0.0)"},"ast":"!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n -1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"!_(\n math.isFinite(\n _/_(\n -1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not","type":"bool"},{"original":{"name":"dyn_error","expr":"math.isFinite(dyn(true))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.isFinite(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.isFinite(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isFinite_double","type":"bool"}]},{"name":"bit_and","tests":[{"original":{"name":"int_int_non_intersect","expr":"math.bitAnd(1, 2)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1~int,\n 2~int\n)~int^math_bitAnd_int_int","type":"int"},{"original":{"name":"int_int_intersect","expr":"math.bitAnd(1, 3)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1~int,\n 3~int\n)~int^math_bitAnd_int_int","type":"int"},{"original":{"name":"int_int_intersect_neg","expr":"math.bitAnd(1, -1)","value":{"int64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1~int,\n -1~int\n)~int^math_bitAnd_int_int","type":"int"},{"original":{"name":"uint_uint_non_intersect","expr":"math.bitAnd(1u, 2u)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1u~uint,\n 2u~uint\n)~uint^math_bitAnd_uint_uint","type":"uint"},{"original":{"name":"uint_uint_intersect","expr":"math.bitAnd(1u, 3u)","value":{"uint64Value":"1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 1u~uint,\n 3u~uint\n)~uint^math_bitAnd_uint_uint","type":"uint"},{"original":{"name":"int_dyn_error","expr":"math.bitAnd(2u, dyn(''))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitAnd(\n 2u^#*expr.Constant_Uint64Value#,\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitAnd(\n 2u~uint,\n dyn(\n \"\"~string\n )~dyn^to_dyn\n)~uint^math_bitAnd_uint_uint","type":"uint"}]},{"name":"bit_or","tests":[{"original":{"name":"int_int_positive","expr":"math.bitOr(1, 2)","value":{"int64Value":"3"}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n 1~int,\n 2~int\n)~int^math_bitOr_int_int","type":"int"},{"original":{"name":"int_int_positive_negative","expr":"math.bitOr(4, -2)","value":{"int64Value":"-2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n 4~int,\n -2~int\n)~int^math_bitOr_int_int","type":"int"},{"original":{"name":"uint_uint","expr":"math.bitOr(1u, 4u)","value":{"uint64Value":"5"}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n 1u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n 1u~uint,\n 4u~uint\n)~uint^math_bitOr_uint_uint","type":"uint"},{"original":{"name":"dyn_int_error","expr":"math.bitOr(dyn(1.2), 1)","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitOr(\n dyn(\n 1.2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitOr(\n dyn(\n 1.2~double\n )~dyn^to_dyn,\n 1~int\n)~int^math_bitOr_int_int","type":"int"}]},{"name":"bit_xor","tests":[{"original":{"name":"int_int_positive","expr":"math.bitXor(1, 3)","value":{"int64Value":"2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n 1~int,\n 3~int\n)~int^math_bitXor_int_int","type":"int"},{"original":{"name":"int_int_positive_negative","expr":"math.bitXor(4, -2)","value":{"int64Value":"-6"}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n 4~int,\n -2~int\n)~int^math_bitXor_int_int","type":"int"},{"original":{"name":"uint_uint","expr":"math.bitXor(1u, 3u)","value":{"uint64Value":"2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n 1u~uint,\n 3u~uint\n)~uint^math_bitXor_uint_uint","type":"uint"},{"original":{"name":"dyn_dyn_error","expr":"math.bitXor(dyn([]), dyn([1]))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitXor(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitXor(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n dyn(\n [\n 1~int\n ]~list(int)\n )~dyn^to_dyn\n)~dyn^math_bitXor_int_int|math_bitXor_uint_uint","type":"dyn"}]},{"name":"bit_not","tests":[{"original":{"name":"int_positive","expr":"math.bitNot(1)","value":{"int64Value":"-2"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 1~int\n)~int^math_bitNot_int_int","type":"int"},{"original":{"name":"int_negative","expr":"math.bitNot(-1)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n -1~int\n)~int^math_bitNot_int_int","type":"int"},{"original":{"name":"int_zero","expr":"math.bitNot(0)","value":{"int64Value":"-1"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 0~int\n)~int^math_bitNot_int_int","type":"int"},{"original":{"name":"uint_positive","expr":"math.bitNot(1u)","value":{"uint64Value":"18446744073709551614"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 1u~uint\n)~uint^math_bitNot_uint_uint","type":"uint"},{"original":{"name":"uint_zero","expr":"math.bitNot(0u)","value":{"uint64Value":"18446744073709551615"}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n 0u~uint\n)~uint^math_bitNot_uint_uint","type":"uint"},{"original":{"name":"dyn_error","expr":"math.bitNot(dyn(''))","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitNot(\n dyn(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitNot(\n dyn(\n \"\"~string\n )~dyn^to_dyn\n)~dyn^math_bitNot_int_int|math_bitNot_uint_uint","type":"dyn"}]},{"name":"bit_shift_left","tests":[{"original":{"name":"int","expr":"math.bitShiftLeft(1, 2)","value":{"int64Value":"4"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1~int,\n 2~int\n)~int^math_bitShiftLeft_int_int","type":"int"},{"original":{"name":"int_large_shift","expr":"math.bitShiftLeft(1, 200)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int","type":"int"},{"original":{"name":"int_negative_large_shift","expr":"math.bitShiftLeft(-1, 200)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n -1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n -1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int","type":"int"},{"original":{"name":"uint","expr":"math.bitShiftLeft(1u, 2)","value":{"uint64Value":"4"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1u~uint,\n 2~int\n)~uint^math_bitShiftLeft_uint_int","type":"uint"},{"original":{"name":"uint_large_shift","expr":"math.bitShiftLeft(1u, 200)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1u~uint,\n 200~int\n)~uint^math_bitShiftLeft_uint_int","type":"uint"},{"original":{"name":"bad_shift","expr":"math.bitShiftLeft(1u, -1)","evalError":{"errors":[{"message":"negative offset"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftLeft_uint_int","type":"uint"},{"original":{"name":"dyn_int_error","expr":"math.bitShiftLeft(dyn(4.3), 1)","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n dyn(\n 4.3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftLeft(\n dyn(\n 4.3~double\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftLeft_int_int|math_bitShiftLeft_uint_int","type":"dyn"}]},{"name":"bit_shift_right","tests":[{"original":{"name":"int","expr":"math.bitShiftRight(1024, 2)","value":{"int64Value":"256"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024~int,\n 2~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"int_large_shift","expr":"math.bitShiftRight(1024, 64)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"int_negative","expr":"math.bitShiftRight(-1024, 3)","value":{"int64Value":"2305843009213693824"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n -1024~int,\n 3~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"int_negative_large_shift","expr":"math.bitShiftRight(-1024, 64)","value":{"int64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n -1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int","type":"int"},{"original":{"name":"uint","expr":"math.bitShiftRight(1024u, 2)","value":{"uint64Value":"256"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024u~uint,\n 2~int\n)~uint^math_bitShiftRight_uint_int","type":"uint"},{"original":{"name":"uint_large_shift","expr":"math.bitShiftRight(1024u, 200)","value":{"uint64Value":"0"}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1024u~uint,\n 200~int\n)~uint^math_bitShiftRight_uint_int","type":"uint"},{"original":{"name":"bad_shift","expr":"math.bitShiftRight(1u, -1)","evalError":{"errors":[{"message":"negative offset"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftRight_uint_int","type":"uint"},{"original":{"name":"dyn_int_error","expr":"math.bitShiftRight(dyn(b'123'), 1)","evalError":{"errors":[{"message":"no such overload"}]}},"ast":"math^#*expr.Expr_IdentExpr#.bitShiftRight(\n dyn(\n b\"123\"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"math.bitShiftRight(\n dyn(\n b\"123\"~bytes\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftRight_int_int|math_bitShiftRight_uint_int","type":"dyn"}]}]},{"name":"namespace","suites":[{"name":"qualified","tests":[{"original":{"name":"self_eval_qualified_lookup","expr":"x.y","typeEnv":[{"name":"x.y","ident":{"type":{"primitive":"BOOL"}}}],"bindings":{"x.y":{"value":{"boolValue":true}}},"value":{"boolValue":true}},"ast":"x^#*expr.Expr_IdentExpr#.y^#*expr.Expr_SelectExpr#","checkedAst":"x.y~bool^x.y","type":"bool"}]},{"name":"namespace","tests":[{"original":{"name":"self_eval_container_lookup","expr":"y","typeEnv":[{"name":"x.y","ident":{"type":{"primitive":"BOOL"}}},{"name":"y","ident":{"type":{"primitive":"STRING"}}}],"container":"x","bindings":{"x.y":{"value":{"boolValue":true}},"y":{"value":{"stringValue":"false"}}},"value":{"boolValue":true}},"ast":"y^#*expr.Expr_IdentExpr#","checkedAst":"x.y~bool^x.y","type":"bool"},{"original":{"name":"self_eval_container_lookup_unchecked","expr":"y","disableCheck":true,"typeEnv":[{"name":"x.y","ident":{"type":{"primitive":"BOOL"}}},{"name":"y","ident":{"type":{"primitive":"BOOL"}}}],"container":"x","bindings":{"x.y":{"value":{"boolValue":true}},"y":{"value":{"boolValue":false}}},"value":{"boolValue":true}},"ast":"y^#*expr.Expr_IdentExpr#","checkedAst":"x.y~bool^x.y","type":"bool"}]}]},{"name":"optionals","suites":[{"name":"optionals","tests":[{"original":{"name":"null","expr":"optional.of(null).hasValue()","value":{"boolValue":true}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n null~null\n)~optional_type(null)^optional_of.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"null_non_zero_value","expr":"optional.ofNonZeroValue(null).hasValue()","value":{"boolValue":false}},"ast":"optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"optional.ofNonZeroValue(\n null~null\n)~optional_type(null)^optional_ofNonZeroValue.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"none_or_none_or_value","expr":"optional.none().or(optional.none()).orValue(42)","value":{"int64Value":"42"}},"ast":"optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.none()~optional_type(int)^optional_none.or(\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^optional_or_optional.orValue(\n 42~int\n)~int^optional_orValue_value","type":"int"},{"original":{"name":"none_optMap_hasValue","expr":"optional.none().optMap(y, y + 1).hasValue()","value":{"boolValue":false}},"ast":"optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n optional.none()~optional_type(dyn)^optional_none.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.none()~optional_type(int)^optional_none.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"empty_map_optFlatMap_hasValue","expr":"{}.?key.optFlatMap(k, k.?subkey).hasValue()","value":{"boolValue":false}},"error":"ERROR: empty_map_optFlatMap_hasValue:1:3: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ..^\nERROR: empty_map_optFlatMap_hasValue:1:24: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | .......................^"},{"original":{"name":"map_empty_submap_optFlatMap_hasValue","expr":"{'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()","value":{"boolValue":false}},"error":"ERROR: map_empty_submap_optFlatMap_hasValue:1:12: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ...........^\nERROR: map_empty_submap_optFlatMap_hasValue:1:33: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ................................^"},{"original":{"name":"map_null_entry_hasValue","expr":"{'null_key': dyn(null)}.?null_key.hasValue()","value":{"boolValue":true}},"error":"ERROR: map_null_entry_hasValue:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.hasValue()\n | .......................^"},{"original":{"name":"map_null_entry_no_such_key","expr":"{'null_key': dyn(null)}.?null_key.invalid.hasValue()","evalError":{"errors":[{"message":"no such key"}]}},"error":"ERROR: map_null_entry_no_such_key:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.invalid.hasValue()\n | .......................^"},{"original":{"name":"map_absent_key_absent_field_none","expr":"{true: dyn(0)}[?false].absent.hasValue()","value":{"boolValue":false}},"error":"ERROR: map_absent_key_absent_field_none:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?false].absent.hasValue()\n | ..............^"},{"original":{"name":"map_present_key_invalid_field","expr":"{true: dyn(0)}[?true].absent.hasValue()","evalError":{"errors":[{"message":"no such key"}]}},"error":"ERROR: map_present_key_invalid_field:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?true].absent.hasValue()\n | ..............^"},{"original":{"name":"map_undefined_entry_hasValue","expr":"{}.?null_key.invalid.hasValue()","value":{"boolValue":false}},"error":"ERROR: map_undefined_entry_hasValue:1:3: unsupported syntax '.?'\n | {}.?null_key.invalid.hasValue()\n | ..^"},{"original":{"name":"map_submap_subkey_optFlatMap_value","expr":"{'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()","value":{"stringValue":"subvalue"}},"error":"ERROR: map_submap_subkey_optFlatMap_value:1:32: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ...............................^\nERROR: map_submap_subkey_optFlatMap_value:1:53: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ....................................................^"},{"original":{"name":"map_submap_optFlatMap_value","expr":"{'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()","value":{"stringValue":""}},"error":"ERROR: map_submap_optFlatMap_value:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | .......................^\nERROR: map_submap_optFlatMap_value:1:45: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | ............................................^"},{"original":{"name":"map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue","expr":"{'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()","value":{"boolValue":false}},"error":"ERROR: map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()\n | .......................^"},{"original":{"name":"optional_of_optMap_value","expr":"optional.of(42).optMap(y, y + 1).value()","value":{"int64Value":"43"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.value()~int^optional_value","type":"int"},{"original":{"name":"optional_ofNonZeroValue_or_optional_value","expr":"optional.ofNonZeroValue(42).or(optional.of(20)).value() == 42","value":{"boolValue":true}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n 42^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.ofNonZeroValue(\n 42~int\n )~optional_type(int)^optional_ofNonZeroValue.or(\n optional.of(\n 20~int\n )~optional_type(int)^optional_of\n )~optional_type(int)^optional_or_optional.value()~int^optional_value,\n 42~int\n)~bool^equals","type":"bool"},{"original":{"name":"ternary_optional_hasValue","expr":"(has({}.x) ? optional.of({}.x) : optional.none()).hasValue()","value":{"boolValue":false}},"ast":"_?_:_(\n {}^#*expr.Expr_StructExpr#.x~test-only~^#*expr.Expr_SelectExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n {}^#*expr.Expr_StructExpr#.x^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n {}~map(dyn, dyn).x~test-only~~bool,\n optional.of(\n {}~map(dyn, dyn).x~dyn\n )~optional_type(dyn)^optional_of,\n optional.none()~optional_type(dyn)^optional_none\n)~optional_type(dyn)^conditional.hasValue()~bool^optional_hasValue","type":"bool"},{"original":{"name":"map_optindex_hasValue","expr":"{}.?x.hasValue()","value":{"boolValue":false}},"error":"ERROR: map_optindex_hasValue:1:3: unsupported syntax '.?'\n | {}.?x.hasValue()\n | ..^"},{"original":{"name":"has_map_optindex","expr":"has({}.?x.y)","value":{"boolValue":false}},"error":"ERROR: has_map_optindex:1:7: unsupported syntax '.?'\n | has({}.?x.y)\n | ......^"},{"original":{"name":"has_map_optindex_field","expr":"has({'x': {'y': 'z'}}.?x.y)","value":{"boolValue":true}},"error":"ERROR: has_map_optindex_field:1:22: unsupported syntax '.?'\n | has({'x': {'y': 'z'}}.?x.y)\n | .....................^"},{"original":{"name":"type","expr":"type(optional.none()) == optional_type","value":{"boolValue":true}},"ast":"_==_(\n type(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional_type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n type(\n optional.none()~optional_type(dyn)^optional_none\n )~type(optional_type(dyn))^type,\n optional_type~type(optional_type)^optional_type\n)~bool^equals","type":"bool"},{"original":{"name":"optional_chaining_1","expr":"optional.ofNonZeroValue('').or(optional.of({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])).orValue('default value')","value":{"stringValue":"goodbye"}},"ast":"optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n _[_](\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"dashed-index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n \"dashed-index\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.ofNonZeroValue(\n \"\"~string\n)~optional_type(string)^optional_ofNonZeroValue.or(\n optional.of(\n _[_](\n {\n \"c\"~string:{\n \"dashed-index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n \"dashed-index\"~string\n )~string^index_map\n )~optional_type(string)^optional_of\n)~optional_type(string)^optional_or_optional.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_2","expr":"{'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')","value":{"stringValue":"goodbye"}},"error":"ERROR: optional_chaining_2:1:37: unsupported syntax '[?'\n | {'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')\n | ....................................^"},{"original":{"name":"optional_chaining_3","expr":"{'c': {}}.c[?'missing-index'].orValue('default value')","value":{"stringValue":"default value"}},"error":"ERROR: optional_chaining_3:1:12: unsupported syntax '[?'\n | {'c': {}}.c[?'missing-index'].orValue('default value')\n | ...........^"},{"original":{"name":"optional_chaining_4","expr":"optional.of({'c': {'index': 'goodbye'}}).c.index.orValue('default value')","value":{"stringValue":"goodbye"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.index^#*expr.Expr_SelectExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n {\n \"c\"~string:{\n \"index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n)~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).index~optional_type(string).orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_5","expr":"optional.of({'c': {}}).c.missing.or(optional.none()[0]).orValue('default value')","value":{"stringValue":"default value"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n {\n \"c\"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.none()~optional_type(list(string))^optional_none,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_6","expr":"optional.of({'c': {}}).c.missing.or(optional.of(['list-value'])[0]).orValue('default value')","value":{"stringValue":"list-value"}},"ast":"optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.of(\n [\n \"list-value\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.of(\n {\n \"c\"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.of(\n [\n \"list-value\"~string\n ]~list(string)\n )~optional_type(list(string))^optional_of,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_7","expr":"optional.of({'c': {'index': 'goodbye'}}).c['index'].orValue('default value')","value":{"stringValue":"goodbye"}},"ast":"_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n \"index\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n optional.of(\n {\n \"c\"~string:{\n \"index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n \"index\"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_8","expr":"optional.of({'c': {}}).c['missing'].orValue('default value')","value":{"stringValue":"default value"}},"ast":"_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n \"missing\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n \"default value\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n optional.of(\n {\n \"c\"~string:{}~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n \"missing\"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n \"default value\"~string\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_9","expr":"has(optional.of({'c': {'entry': 'hello world'}}).c) \u0026\u0026 !has(optional.of({'c': {'entry': 'hello world'}}).c.missing)","value":{"boolValue":true}},"ast":"_\u0026\u0026_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"entry\"^#*expr.Constant_StringValue#:\"hello world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c~test-only~^#*expr.Expr_SelectExpr#,\n !_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"entry\"^#*expr.Constant_StringValue#:\"hello world\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing~test-only~^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n optional.of(\n {\n \"c\"~string:{\n \"entry\"~string:\"hello world\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~test-only~~bool,\n !_(\n optional.of(\n {\n \"c\"~string:{\n \"entry\"~string:\"hello world\"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).missing~test-only~~bool\n )~bool^logical_not\n)~bool^logical_and","type":"bool"},{"original":{"name":"optional_chaining_10","expr":"optional.ofNonZeroValue({'c': {'dashed-index': 'goodbye'}}.a.z).orValue({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])","evalError":{"errors":[{"message":"no such key"}]}},"ast":"optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"dashed-index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.a^#*expr.Expr_SelectExpr#.z^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n _[_](\n {\n \"c\"^#*expr.Constant_StringValue#:{\n \"dashed-index\"^#*expr.Constant_StringValue#:\"goodbye\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n \"dashed-index\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"optional.ofNonZeroValue(\n {\n \"c\"~string:{\n \"dashed-index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string)).a~map(string, string).z~string\n)~optional_type(string)^optional_ofNonZeroValue.orValue(\n _[_](\n {\n \"c\"~string:{\n \"dashed-index\"~string:\"goodbye\"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n \"dashed-index\"~string\n )~string^index_map\n)~string^optional_orValue_value","type":"string"},{"original":{"name":"optional_chaining_11","expr":"{'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()","value":{"int64Value":"7"}},"error":"ERROR: optional_chaining_11:1:35: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ..................................^\nERROR: optional_chaining_11:1:84: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ...................................................................................^"},{"original":{"name":"optional_chaining_12","expr":"{?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}","value":{"mapValue":{"entries":[{"key":{"stringValue":"nested_map"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"map"},"value":{"mapValue":{"entries":[{"key":{"stringValue":"dashed-index"},"value":{"stringValue":"goodbye"}}]}}}]}}}]}}},"error":"ERROR: optional_chaining_12:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}\n | .^"},{"original":{"name":"optional_chaining_13","expr":"{?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}","value":{"mapValue":{"entries":[{"key":{"stringValue":"singleton"},"value":{"boolValue":true}}]}}},"error":"ERROR: optional_chaining_13:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}\n | .^"},{"original":{"name":"optional_chaining_14","expr":"[?{}.?c, ?optional.of(42), ?optional.none()]","value":{"listValue":{"values":[{"int64Value":"42"}]}}},"error":"ERROR: optional_chaining_14:1:2: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .^\nERROR: optional_chaining_14:1:5: unsupported syntax '.?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ....^\nERROR: optional_chaining_14:1:10: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .........^\nERROR: optional_chaining_14:1:28: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ...........................^"},{"original":{"name":"optional_chaining_15","expr":"[?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]","value":{"listValue":{}}},"error":"ERROR: optional_chaining_15:1:2: unsupported syntax '?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | .^\nERROR: optional_chaining_15:1:36: unsupported syntax '.?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | ...................................^"},{"original":{"name":"optional_chaining_16","expr":"optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_chaining_16:1:26: unsupported syntax '?'\n | optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()\n | .........................^"},{"original":{"name":"has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field","expr":"has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:18: unsupported syntax '?'\n | has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)\n | .................^"},{"original":{"name":"optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field","expr":"optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:38: unsupported syntax '?'\n | optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()\n | .....................................^"},{"original":{"name":"struct_map_optindex_field","expr":"TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"error":"ERROR: struct_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string\n | .............^"},{"original":{"name":"struct_optional_ofNonZeroValue_map_optindex_field","expr":"TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"error":"ERROR: struct_optional_ofNonZeroValue_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string\n | .............^"},{"original":{"name":"struct_map_optindex_field_nested","expr":"TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{"entries":[{"key":{"stringValue":"hello"},"value":{"stringValue":"world"}}]}}},"error":"ERROR: struct_map_optindex_field_nested:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string\n | .............^"},{"original":{"name":"struct_list_optindex_field","expr":"TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"greetings"},{"stringValue":"world"}]}}},"error":"ERROR: struct_list_optindex_field:1:45: unsupported syntax '?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ............................................^\nERROR: struct_list_optindex_field:1:83: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ..................................................................................^"},{"original":{"name":"optional_empty_map_optindex_hasValue","expr":"optional.of({}).?c.hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_empty_map_optindex_hasValue:1:16: unsupported syntax '.?'\n | optional.of({}).?c.hasValue()\n | ...............^"},{"original":{"name":"empty_struct_optindex_hasValue","expr":"TestAllTypes{}.?repeated_string.hasValue()","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: empty_struct_optindex_hasValue:1:15: unsupported syntax '.?'\n | TestAllTypes{}.?repeated_string.hasValue()\n | ..............^"},{"original":{"name":"optional_empty_struct_optindex_hasValue","expr":"optional.of(TestAllTypes{}).?repeated_string.hasValue()","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: optional_empty_struct_optindex_hasValue:1:28: unsupported syntax '.?'\n | optional.of(TestAllTypes{}).?repeated_string.hasValue()\n | ...........................^"},{"original":{"name":"optional_none_optselect_hasValue","expr":"optional.none().?repeated_string.hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_none_optselect_hasValue:1:16: unsupported syntax '.?'\n | optional.none().?repeated_string.hasValue()\n | ...............^"},{"original":{"name":"struct_optindex_value","expr":"TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"foo"}]}}},"error":"ERROR: struct_optindex_value:1:39: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()\n | ......................................^"},{"original":{"name":"optional_struct_optindex_value","expr":"optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()","container":"cel.expr.conformance.proto2","value":{"listValue":{"values":[{"stringValue":"foo"}]}}},"error":"ERROR: optional_struct_optindex_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()\n | ...................................................^"},{"original":{"name":"optional_struct_optindex_index_value","expr":"optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()","container":"cel.expr.conformance.proto2","value":{"stringValue":"foo"}},"error":"ERROR: optional_struct_optindex_index_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()\n | ...................................................^"},{"original":{"name":"empty_list_optindex_hasValue","expr":"[][?0].hasValue()","value":{"boolValue":false}},"error":"ERROR: empty_list_optindex_hasValue:1:3: unsupported syntax '[?'\n | [][?0].hasValue()\n | ..^"},{"original":{"name":"optional_empty_list_optindex_hasValue","expr":"optional.of([])[?0].hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_empty_list_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.of([])[?0].hasValue()\n | ...............^"},{"original":{"name":"optional_none_optindex_hasValue","expr":"optional.none()[?0].hasValue()","value":{"boolValue":false}},"error":"ERROR: optional_none_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.none()[?0].hasValue()\n | ...............^"},{"original":{"name":"list_optindex_value","expr":"['foo'][?0].value()","value":{"stringValue":"foo"}},"error":"ERROR: list_optindex_value:1:8: unsupported syntax '[?'\n | ['foo'][?0].value()\n | .......^"},{"original":{"name":"optional_list_optindex_value","expr":"optional.of(['foo'])[?0].value()","value":{"stringValue":"foo"}},"error":"ERROR: optional_list_optindex_value:1:21: unsupported syntax '[?'\n | optional.of(['foo'])[?0].value()\n | ....................^"},{"original":{"name":"map_key_mixed_type_optindex_value","expr":"{true: 1, 2: 2, 5u: 3}[?true].value()","value":{"int64Value":"1"}},"error":"ERROR: map_key_mixed_type_optindex_value:1:23: unsupported syntax '[?'\n | {true: 1, 2: 2, 5u: 3}[?true].value()\n | ......................^"},{"original":{"name":"map_key_mixed_numbers_double_key_optindex_value","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()","value":{"doubleValue":3}},"error":"ERROR: map_key_mixed_numbers_double_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()\n | ..........................^"},{"original":{"name":"map_key_mixed_numbers_uint_key_optindex_value","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()","value":{"doubleValue":2}},"error":"ERROR: map_key_mixed_numbers_uint_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()\n | ..........................^"},{"original":{"name":"map_key_mixed_numbers_int_key_optindex_value","expr":"{1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()","value":{"doubleValue":1}},"error":"ERROR: map_key_mixed_numbers_int_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()\n | ..........................^"},{"original":{"name":"optional_eq_none_none","expr":"optional.none() == optional.none()","value":{"boolValue":true}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^equals","type":"bool"},{"original":{"name":"optional_eq_none_int","expr":"optional.none() == optional.of(1)","value":{"boolValue":false}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals","type":"bool"},{"original":{"name":"optional_eq_int_none","expr":"optional.of(1) == optional.none()","value":{"boolValue":false}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^equals","type":"bool"},{"original":{"name":"optional_eq_int_int","expr":"optional.of(1) == optional.of(1)","value":{"boolValue":true}},"ast":"_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals","type":"bool"},{"original":{"name":"optional_ne_none_none","expr":"optional.none() != optional.none()","value":{"boolValue":false}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^not_equals","type":"bool"},{"original":{"name":"optional_ne_none_int","expr":"optional.none() != optional.of(1)","value":{"boolValue":true}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals","type":"bool"},{"original":{"name":"optional_ne_int_none","expr":"optional.of(1) != optional.none()","value":{"boolValue":true}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^not_equals","type":"bool"},{"original":{"name":"optional_ne_int_int","expr":"optional.of(1) != optional.of(1)","value":{"boolValue":false}},"ast":"_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals","type":"bool"},{"original":{"name":"map_optional_has","expr":"has({'foo': optional.none()}.foo)","value":{"boolValue":true}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"foo\"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~test-only~~bool","type":"bool"},{"original":{"name":"map_optional_select_has","expr":"has({'foo': optional.none()}.foo.bar)","value":{"boolValue":false}},"ast":"{\n \"foo\"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo^#*expr.Expr_SelectExpr#.bar~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"foo\"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~optional_type(dyn).bar~test-only~~bool","type":"bool"},{"original":{"name":"map_optional_entry_has","expr":"has({?'foo': optional.none()}.foo)","value":{"boolValue":false}},"error":"ERROR: map_optional_entry_has:1:6: unsupported syntax '?'\n | has({?'foo': optional.none()}.foo)\n | .....^"}]}]},{"name":"parse","suites":[{"name":"nest","tests":[{"original":{"name":"list_index","description":"Member = Member '[' Expr ']'. Nested indices are supported up to 12 times.","expr":"a[a[a[a[a[a[a[a[a[a[a[a[0]]]]]]]]]]]]","typeEnv":[{"name":"a","ident":{"type":{"listType":{"elemType":{"primitive":"INT64"}}}}}],"bindings":{"a":{"value":{"listValue":{"values":[{"int64Value":"0"}]}}}},"value":{"int64Value":"0"}},"ast":"_[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n 0~int\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n)~int^index_list","type":"int"},{"original":{"name":"message_literal","description":"Member = Member '{' [FieldInits] '}'. Nested messages supported up to 12 levels deep.","expr":"NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{payload: TestAllTypes{single_int64: 137}}}}}}}}}}}}.payload.single_int64","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n payload:TestAllTypes{\n single_int64:137^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.payload^#*expr.Expr_SelectExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n payload:cel.expr.conformance.proto3.TestAllTypes{\n single_int64:137~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int64~int","type":"int"},{"original":{"name":"funcall","description":"Primary = ['.'] IDENT ['(' [ExprList] ')']. Nested function calls supported up to 12 levels deep.","expr":"int(uint(int(uint(int(uint(int(uint(int(uint(int(uint(7))))))))))))","value":{"int64Value":"7"}},"ast":"int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7~int\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n)~int^uint64_to_int64","type":"int"},{"original":{"name":"list_literal","description":"Primary = '[' [ExprList] ']'. Nested list literals up to 12 levels deep.","expr":"size([[[[[[[[[[[[0]]]]]]]]]]]])","value":{"int64Value":"1"}},"ast":"size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0~int\n ]~list(int)\n ]~list(list(int))\n ]~list(list(list(int)))\n ]~list(list(list(list(int))))\n ]~list(list(list(list(list(int)))))\n ]~list(list(list(list(list(list(int))))))\n ]~list(list(list(list(list(list(list(int)))))))\n ]~list(list(list(list(list(list(list(list(int))))))))\n ]~list(list(list(list(list(list(list(list(list(int)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(int))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(int)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(int))))))))))))\n)~int^size_list","type":"int"},{"original":{"name":"map_literal","description":"Primary = '{' [MapInits] '}'. Nested map literals up to 12 levels deep.","expr":"size({0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: 'foo'}}}}}}}}}}}})","value":{"int64Value":"1"}},"ast":"size(\n {\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n {\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:\"foo\"~string\n }~map(int, string)\n }~map(int, map(int, string))\n }~map(int, map(int, map(int, string)))\n }~map(int, map(int, map(int, map(int, string))))\n }~map(int, map(int, map(int, map(int, map(int, string)))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, string))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))))\n)~int^size_map","type":"int"},{"original":{"name":"parens","description":"Primary = '(' Expr ')'","expr":"((((((((((((((((((((((((((((((((7))))))))))))))))))))))))))))))))","value":{"int64Value":"7"}},"error":"ERROR: parens:-1:0: expression recursion limit exceeded: 32"}]},{"name":"repeat","tests":[{"original":{"name":"conditional","description":"Expr = ConditionalOr ['?' ConditionalOr ':' Expr]. Chained ternary operators up to 24 levels.","expr":"true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : false","value":{"boolValue":true}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n false~bool\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n)~bool^conditional","type":"bool"},{"original":{"name":"or","description":"ConditionalOr = [ConditionalOr '||'] ConditionalAnd. Logical OR statements with 32 conditions.","expr":"false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || true","value":{"boolValue":true}},"ast":"_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n true~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n)~bool^logical_or","type":"bool"},{"original":{"name":"and","description":"ConditionalAnd = [ConditionalAnd '\u0026\u0026'] Relation. Logical AND statements with 32 conditions.","expr":"true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 false","value":{"boolValue":false}},"ast":"_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n false~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n)~bool^logical_and","type":"bool"},{"original":{"name":"add_sub","description":"Addition = [Addition ('+' | '-')] Multiplication. Addition operators are supported up to 24 times consecutively.","expr":"3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3","value":{"int64Value":"3"}},"ast":"_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3~int,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n)~int^add_int64","type":"int"},{"original":{"name":"mul_div","description":"Multiplication = [Multiplication ('*' | '/' | '%')] Unary. Multiplication operators are supported up to 24 times consecutively.","expr":"4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4","value":{"int64Value":"4"}},"ast":"_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4~int,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n)~int^divide_int64","type":"int"},{"original":{"name":"not","description":"Unary = '!' {'!'} Member","expr":"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!true","value":{"boolValue":true}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"unary_neg","description":"Unary = '-' {'-'} Member","expr":"--------------------------------19","value":{"int64Value":"19"}},"ast":"19^#*expr.Constant_Int64Value#","checkedAst":"19~int","type":"int"},{"original":{"name":"select","description":"Member = Member '.' IDENT ['(' [ExprList] ')']. Selection is supported up to 12 times consecutively.","expr":"NestedTestAllTypes{}.child.child.child.child.child.child.child.child.child.child.payload.single_int32","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"NestedTestAllTypes{}^#*expr.Expr_StructExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.payload^#*expr.Expr_SelectExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.NestedTestAllTypes{}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int32~int","type":"int"},{"original":{"name":"index","description":"Member = Member '[' Expr ']'. Indexing is supported up to 12 times consecutively.","expr":"[[[[[[[[[[[['foo']]]]]]]]]]]][0][0][0][0][0][0][0][0][0][0][0][0]","value":{"stringValue":"foo"}},"ast":"_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n \"foo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n \"foo\"~string\n ]~list(string)\n ]~list(list(string))\n ]~list(list(list(string)))\n ]~list(list(list(list(string))))\n ]~list(list(list(list(list(string)))))\n ]~list(list(list(list(list(list(string))))))\n ]~list(list(list(list(list(list(list(string)))))))\n ]~list(list(list(list(list(list(list(list(string))))))))\n ]~list(list(list(list(list(list(list(list(list(string)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(string))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(string)))))))))))),\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(string))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(string)))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(string))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(string)))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(string))))))^index_list,\n 0~int\n )~list(list(list(list(list(string)))))^index_list,\n 0~int\n )~list(list(list(list(string))))^index_list,\n 0~int\n )~list(list(list(string)))^index_list,\n 0~int\n )~list(list(string))^index_list,\n 0~int\n )~list(string)^index_list,\n 0~int\n)~string^index_list","type":"string"},{"original":{"name":"list_literal","description":"Primary = '[' [ExprList] ']'. List literals with up to 32 elements.","expr":"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31][17]","value":{"int64Value":"17"}},"ast":"_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#,\n 11^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#,\n 14^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#,\n 16^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#,\n 18^#*expr.Constant_Int64Value#,\n 19^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#,\n 21^#*expr.Constant_Int64Value#,\n 22^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#,\n 24^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#,\n 26^#*expr.Constant_Int64Value#,\n 27^#*expr.Constant_Int64Value#,\n 28^#*expr.Constant_Int64Value#,\n 29^#*expr.Constant_Int64Value#,\n 30^#*expr.Constant_Int64Value#,\n 31^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int,\n 6~int,\n 7~int,\n 8~int,\n 9~int,\n 10~int,\n 11~int,\n 12~int,\n 13~int,\n 14~int,\n 15~int,\n 16~int,\n 17~int,\n 18~int,\n 19~int,\n 20~int,\n 21~int,\n 22~int,\n 23~int,\n 24~int,\n 25~int,\n 26~int,\n 27~int,\n 28~int,\n 29~int,\n 30~int,\n 31~int\n ]~list(int),\n 17~int\n)~int^index_list","type":"int"},{"original":{"name":"map_literal","description":"Primary = '{' [MapInits] '}'. Map literals with up to 32 entries.","expr":"{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine', 10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen', 14: 'fourteen', 15: 'fifteen', 16: 'sixteen', 17: 'seventeen', 18: 'eighteen', 19: 'nineteen', 20: 'twenty', 21: 'twenty-one', 22: 'twenty-two', 23: 'twenty-three', 24: 'twenty-four', 25: 'twenty-five', 26: 'twenty-six', 27: 'twenty-seven', 28: 'twenty-eight', 29: 'twenty-nine', 30: 'thirty', 31: 'thirty-one'}[17]","value":{"stringValue":"seventeen"}},"ast":"_[_](\n {\n 0^#*expr.Constant_Int64Value#:\"zero\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:\"one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:\"two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:\"three\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 4^#*expr.Constant_Int64Value#:\"four\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:\"five\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:\"six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:\"seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:\"eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 9^#*expr.Constant_Int64Value#:\"nine\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 10^#*expr.Constant_Int64Value#:\"ten\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 11^#*expr.Constant_Int64Value#:\"eleven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 12^#*expr.Constant_Int64Value#:\"twelve\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 13^#*expr.Constant_Int64Value#:\"thirteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 14^#*expr.Constant_Int64Value#:\"fourteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 15^#*expr.Constant_Int64Value#:\"fifteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 16^#*expr.Constant_Int64Value#:\"sixteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 17^#*expr.Constant_Int64Value#:\"seventeen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 18^#*expr.Constant_Int64Value#:\"eighteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 19^#*expr.Constant_Int64Value#:\"nineteen\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 20^#*expr.Constant_Int64Value#:\"twenty\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 21^#*expr.Constant_Int64Value#:\"twenty-one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 22^#*expr.Constant_Int64Value#:\"twenty-two\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 23^#*expr.Constant_Int64Value#:\"twenty-three\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 24^#*expr.Constant_Int64Value#:\"twenty-four\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 25^#*expr.Constant_Int64Value#:\"twenty-five\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 26^#*expr.Constant_Int64Value#:\"twenty-six\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 27^#*expr.Constant_Int64Value#:\"twenty-seven\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 28^#*expr.Constant_Int64Value#:\"twenty-eight\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 29^#*expr.Constant_Int64Value#:\"twenty-nine\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 30^#*expr.Constant_Int64Value#:\"thirty\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 31^#*expr.Constant_Int64Value#:\"thirty-one\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n 0~int:\"zero\"~string,\n 1~int:\"one\"~string,\n 2~int:\"two\"~string,\n 3~int:\"three\"~string,\n 4~int:\"four\"~string,\n 5~int:\"five\"~string,\n 6~int:\"six\"~string,\n 7~int:\"seven\"~string,\n 8~int:\"eight\"~string,\n 9~int:\"nine\"~string,\n 10~int:\"ten\"~string,\n 11~int:\"eleven\"~string,\n 12~int:\"twelve\"~string,\n 13~int:\"thirteen\"~string,\n 14~int:\"fourteen\"~string,\n 15~int:\"fifteen\"~string,\n 16~int:\"sixteen\"~string,\n 17~int:\"seventeen\"~string,\n 18~int:\"eighteen\"~string,\n 19~int:\"nineteen\"~string,\n 20~int:\"twenty\"~string,\n 21~int:\"twenty-one\"~string,\n 22~int:\"twenty-two\"~string,\n 23~int:\"twenty-three\"~string,\n 24~int:\"twenty-four\"~string,\n 25~int:\"twenty-five\"~string,\n 26~int:\"twenty-six\"~string,\n 27~int:\"twenty-seven\"~string,\n 28~int:\"twenty-eight\"~string,\n 29~int:\"twenty-nine\"~string,\n 30~int:\"thirty\"~string,\n 31~int:\"thirty-one\"~string\n }~map(int, string),\n 17~int\n)~string^index_map","type":"string"},{"original":{"name":"message_literal","description":"Member = Member '{' [FieldInits] '}'. Message literals with up to 32 fields.","expr":"TestAllTypes{single_int32: 5, single_int64: 10, single_uint32: 15u, single_uint64: 20u, single_sint32: 25, single_sint64: 30, single_fixed32: 35u, single_fixed64: 40u, single_float: 45.0, single_double: 50.0, single_bool: true, single_string: 'sixty', single_bytes: b'sixty-five', single_value: 70.0, single_int64_wrapper: 75, single_int32_wrapper: 80, single_double_wrapper: 85.0, single_float_wrapper: 90.0, single_uint64_wrapper: 95u, single_uint32_wrapper: 100u, single_string_wrapper: 'one hundred five', single_bool_wrapper: true, repeated_int32: [115], repeated_int64: [120], repeated_uint32: [125u], repeated_uint64: [130u], repeated_sint32: [135], repeated_sint64: [140], repeated_fixed32: [145u], repeated_fixed64: [150u], repeated_sfixed32: [155], repeated_float: [160.0]}.single_sint64","container":"cel.expr.conformance.proto3","value":{"int64Value":"30"}},"ast":"TestAllTypes{\n single_int32:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int64:10^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32:15u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64:20u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint32:25^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint64:30^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed32:35u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed64:40u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_float:45^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_double:50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n single_string:\"sixty\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bytes:b\"sixty-five\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n single_value:70^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_int64_wrapper:75^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int32_wrapper:80^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_double_wrapper:85^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_float_wrapper:90^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64_wrapper:95u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32_wrapper:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string_wrapper:\"one hundred five\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int32:[\n 115^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int64:[\n 120^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint32:[\n 125u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint64:[\n 130u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint32:[\n 135^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint64:[\n 140^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed32:[\n 145u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed64:[\n 150u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sfixed32:[\n 155^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_float:[\n 160^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:5~int,\n single_int64:10~int,\n single_uint32:15u~uint,\n single_uint64:20u~uint,\n single_sint32:25~int,\n single_sint64:30~int,\n single_fixed32:35u~uint,\n single_fixed64:40u~uint,\n single_float:45~double,\n single_double:50~double,\n single_bool:true~bool,\n single_string:\"sixty\"~string,\n single_bytes:b\"sixty-five\"~bytes,\n single_value:70~double,\n single_int64_wrapper:75~int,\n single_int32_wrapper:80~int,\n single_double_wrapper:85~double,\n single_float_wrapper:90~double,\n single_uint64_wrapper:95u~uint,\n single_uint32_wrapper:100u~uint,\n single_string_wrapper:\"one hundred five\"~string,\n single_bool_wrapper:true~bool,\n repeated_int32:[\n 115~int\n ]~list(int),\n repeated_int64:[\n 120~int\n ]~list(int),\n repeated_uint32:[\n 125u~uint\n ]~list(uint),\n repeated_uint64:[\n 130u~uint\n ]~list(uint),\n repeated_sint32:[\n 135~int\n ]~list(int),\n repeated_sint64:[\n 140~int\n ]~list(int),\n repeated_fixed32:[\n 145u~uint\n ]~list(uint),\n repeated_fixed64:[\n 150u~uint\n ]~list(uint),\n repeated_sfixed32:[\n 155~int\n ]~list(int),\n repeated_float:[\n 160~double\n ]~list(double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_sint64~int","type":"int"}]},{"name":"string_literals","tests":[{"original":{"name":"single_quoted","expr":"'hello'","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"double_quoted","expr":"\"hello\"","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"triple_single_quoted","expr":"'''hello'''","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"triple_double_quoted","expr":"\"\"\"hello\"\"\"","value":{"stringValue":"hello"}},"ast":"\"hello\"^#*expr.Constant_StringValue#","checkedAst":"\"hello\"~string","type":"string"},{"original":{"name":"single_quoted_escaped_punctuation","expr":"' \\\\ \\? \\\" \\' \\` '","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_punctuation","expr":"\" \\\\ \\? \\\" \\' \\` \"","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_punctuation","expr":"''' \\\\ \\? \\\" \\' \\` '''","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_punctuation","expr":"\"\"\" \\\\ \\? \\\" \\' \\` \"\"\"","value":{"stringValue":" \\ ? \" ' ` "}},"ast":"\" \\\\ ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\ ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_punctuation","expr":"''' ? \" ' ` '''","value":{"stringValue":" ? \" ' ` "}},"ast":"\" ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_punctuation","expr":"\"\"\" ? \" ' ` \"\"\"","value":{"stringValue":" ? \" ' ` "}},"ast":"\" ? \\\" ' ` \"^#*expr.Constant_StringValue#","checkedAst":"\" ? \\\" ' ` \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_special_control_characters","expr":"' \\a \\b \\f \\t \\v '","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_special_control_characters","expr":"\" \\a \\b \\f \\t \\v \"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"single_quoted_unescaped_special_control_characters","expr":"' \u0007 \b \f \t \u000b '","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"double_quoted_unescaped_special_control_characters","expr":"\" \u0007 \b \f \t \u000b \"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_special_control_characters","expr":"''' \\a \\b \\f \\t \\v '''","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_special_control_characters","expr":"\"\"\" \\a \\b \\f \\t \\v \"\"\"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_special_control_characters","expr":"''' \u0007 \b \f \t \u000b '''","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_special_control_characters","expr":"\"\"\" \u0007 \b \f \t \u000b \"\"\"","value":{"stringValue":" \u0007 \b \f \t \u000b "}},"ast":"\" \\a \\b \\f \\t \\v \"^#*expr.Constant_StringValue#","checkedAst":"\" \\a \\b \\f \\t \\v \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_line_feed","expr":"' \\n '","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_line_feed","expr":"\" \\n \"","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_line_feed","expr":"''' \\n '''","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_line_feed","expr":"\"\"\" \\n \"\"\"","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_line_feed","expr":"''' \n '''","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_line_feed","expr":"\"\"\" \n \"\"\"","value":{"stringValue":" \n "}},"ast":"\" \\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\n \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_carriage_return","expr":"' \\r '","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_carriage_return","expr":"\" \\r \"","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_carriage_return","expr":"''' \\r '''","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_carriage_return","expr":"\"\"\" \\r \"\"\"","value":{"stringValue":" \r "}},"ast":"\" \\r \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_windows_line_end","expr":"' \\r\\n '","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_windows_line_end","expr":"\" \\r\\n \"","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_windows_line_end","expr":"''' \\r\\n '''","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_windows_line_end","expr":"\"\"\" \\r\\n \"\"\"","value":{"stringValue":" \r\n "}},"ast":"\" \\r\\n \"^#*expr.Constant_StringValue#","checkedAst":"\" \\r\\n \"~string","type":"string"},{"original":{"name":"single_quoted_escaped_all_control_characters","expr":"' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_escaped_all_control_characters","expr":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_unescaped_all_control_characters","expr":"' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_unescaped_all_control_characters","expr":"\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_escaped_all_control_characters","expr":"''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_escaped_all_control_characters","expr":"\"\"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"\"\"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_unescaped_all_control_characters","expr":"''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_unescaped_all_control_characters","expr":"\"\"\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"\"\"","value":{"stringValue":" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "}},"ast":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_octal_escapes","expr":"' \\000 \\012 \\177 '","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_octal_escapes","expr":"\" \\000 \\012 \\177 \"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_octal_escapes","expr":"''' \\000 \\012 \\177 '''","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_octal_escapes","expr":"\"\"\" \\000 \\012 \\177 \"\"\"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_lower_x_escapes","expr":"' \\x00 \\x0A \\x7F '","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_lower_x_escapes","expr":"\" \\x00 \\x0A \\x7F \"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_lower_x_escapes","expr":"''' \\x00 \\x0A \\x7F '''","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_lower_x_escapes","expr":"\"\"\" \\x00 \\x0A \\x7F \"\"\"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_upper_x_escapes","expr":"' \\X00 \\X0A \\X7F '","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"double_quoted_upper_x_escapes","expr":"\" \\X00 \\X0A \\X7F \"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_single_quoted_upper_x_escapes","expr":"''' \\X00 \\X0A \\X7F '''","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"triple_double_quoted_upper_x_escapes","expr":"\"\"\" \\X00 \\X0A \\X7F \"\"\"","value":{"stringValue":" \u0000 \n  "}},"ast":"\" \\x00 \\n \\x7f \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f \"~string","type":"string"},{"original":{"name":"single_quoted_lower_u_escapes","expr":"' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"double_quoted_lower_u_escapes","expr":"\" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB \"","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"triple_single_quoted_lower_u_escapes","expr":"''' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '''","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"triple_double_quoted_lower_u_escapes","expr":"\"\"\" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB \"\"\"","value":{"stringValue":" \u0000 \n  Ā  "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb \"~string","type":"string"},{"original":{"name":"single_quoted_upper_u_escapes","expr":"' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"double_quoted_upper_u_escapes","expr":"\" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C \"","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"triple_single_quoted_upper_u_escapes","expr":"''' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '''","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"triple_double_quoted_upper_u_escapes","expr":"\"\"\" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C \"\"\"","value":{"stringValue":" \u0000 \n  Ā  𐀀 😬 "}},"ast":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 \"~string","type":"string"},{"original":{"name":"mixed_case_hex_single_quoted_escapes","expr":"' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"mixed_case_hex_double_quoted_escapes","expr":"\" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB \"","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"mixed_case_hex_triple_single_quoted_escapes","expr":"''' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '''","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"mixed_case_hex_triple_double_quoted_escapes","expr":"\"\"\" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB \"\"\"","value":{"stringValue":" J K L M ƫ ƫ "}},"ast":"\" J K L M ƫ ƫ \"^#*expr.Constant_StringValue#","checkedAst":"\" J K L M ƫ ƫ \"~string","type":"string"},{"original":{"name":"unassigned_code_point_single_quoted_escapes","expr":"' \\U00088888 '","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_double_quoted_escapes","expr":"\" \\U00088888 \"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_single_quoted_escapes","expr":"''' \\U00088888 '''","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_double_quoted_escapes","expr":"\"\"\" \\U00088888 \"\"\"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_single_quoted_unescaped","expr":"' 򈢈 '","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_double_quoted_unescaped","expr":"\" 򈢈 \"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_single_quoted_unescaped","expr":"''' 򈢈 '''","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"unassigned_code_point_triple_double_quoted_unescaped","expr":"\"\"\" 򈢈 \"\"\"","value":{"stringValue":" 򈢈 "}},"ast":"\" \\U00088888 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\U00088888 \"~string","type":"string"},{"original":{"name":"raw_single_quoted_escapes","expr":"r' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"stringValue":" \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"raw_double_quoted_escapes","expr":"r\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"stringValue":" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"raw_triple_single_quoted_escapes","expr":"r''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"raw_triple_double_quoted_escapes","expr":"r\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_single_quoted_escapes","expr":"R' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"stringValue":" \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_double_quoted_escapes","expr":"R\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"stringValue":" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_triple_single_quoted_escapes","expr":"R''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"},{"original":{"name":"upper_raw_triple_double_quoted_escapes","expr":"R\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"stringValue":" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "}},"ast":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_StringValue#","checkedAst":"\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~string","type":"string"}]},{"name":"bytes_literals","tests":[{"original":{"name":"single_quoted","expr":"b'hello'","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"double_quoted","expr":"b\"hello\"","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted","expr":"b'''hello'''","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted","expr":"b\"\"\"hello\"\"\"","value":{"bytesValue":"aGVsbG8="}},"ast":"b\"hello\"^#*expr.Constant_BytesValue#","checkedAst":"b\"hello\"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_punctuation","expr":"b' \\\\ \\? \\\" \\' \\` '","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_punctuation","expr":"b\" \\\\ \\? \\\" \\' \\` \"","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_punctuation","expr":"b''' \\\\ \\? \\\" \\' \\` '''","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_punctuation","expr":"b\"\"\" \\\\ \\? \\\" \\' \\` \"\"\"","value":{"bytesValue":"IFwgPyAiICcgYCA="}},"ast":"b\" \\\\ ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\ ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_punctuation","expr":"b''' ? \" ' ` '''","value":{"bytesValue":"ID8gIiAnIGAg"}},"ast":"b\" ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_punctuation","expr":"b\"\"\" ? \" ' ` \"\"\"","value":{"bytesValue":"ID8gIiAnIGAg"}},"ast":"b\" ? \\\" ' ` \"^#*expr.Constant_BytesValue#","checkedAst":"b\" ? \\\" ' ` \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_special_control_characters","expr":"b' \\a \\b \\f \\t \\v '","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_special_control_characters","expr":"b\" \\a \\b \\f \\t \\v \"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_unescaped_special_control_characters","expr":"b' \u0007 \b \f \t \u000b '","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_unescaped_special_control_characters","expr":"b\" \u0007 \b \f \t \u000b \"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_special_control_characters","expr":"b''' \\a \\b \\f \\t \\v '''","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_special_control_characters","expr":"b\"\"\" \\a \\b \\f \\t \\v \"\"\"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_special_control_characters","expr":"b''' \u0007 \b \f \t \u000b '''","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_special_control_characters","expr":"b\"\"\" \u0007 \b \f \t \u000b \"\"\"","value":{"bytesValue":"IAcgCCAMIAkgCyA="}},"ast":"b\" \\a \\b \\f \\t \\v \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\a \\b \\f \\t \\v \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_line_feed","expr":"b' \\n '","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_line_feed","expr":"b\" \\n \"","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_line_feed","expr":"b''' \\n '''","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_line_feed","expr":"b\"\"\" \\n \"\"\"","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_line_feed","expr":"b''' \n '''","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_line_feed","expr":"b\"\"\" \n \"\"\"","value":{"bytesValue":"IAog"}},"ast":"b\" \\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\n \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_carriage_return","expr":"b' \\r '","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_carriage_return","expr":"b\" \\r \"","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_carriage_return","expr":"b''' \\r '''","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_carriage_return","expr":"b\"\"\" \\r \"\"\"","value":{"bytesValue":"IA0g"}},"ast":"b\" \\r \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_windows_line_end","expr":"b' \\r\\n '","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_windows_line_end","expr":"b\" \\r\\n \"","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_windows_line_end","expr":"b''' \\r\\n '''","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_windows_line_end","expr":"b\"\"\" \\r\\n \"\"\"","value":{"bytesValue":"IA0KIA=="}},"ast":"b\" \\r\\n \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\r\\n \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_escaped_all_control_characters","expr":"b' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_escaped_all_control_characters","expr":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_unescaped_all_control_characters","expr":"b' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_unescaped_all_control_characters","expr":"b\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_escaped_all_control_characters","expr":"b''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_escaped_all_control_characters","expr":"b\"\"\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F \"\"\"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_unescaped_all_control_characters","expr":"b''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_unescaped_all_control_characters","expr":"b\"\"\" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  \"\"\"","value":{"bytesValue":"IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA=="}},"ast":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_octal_escapes","expr":"b' \\000 \\012 \\177 \\377 '","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_octal_escapes","expr":"b\" \\000 \\012 \\177 \\377 \"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_octal_escapes","expr":"b''' \\000 \\012 \\177 \\377 '''","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_octal_escapes","expr":"b\"\"\" \\000 \\012 \\177 \\377 \"\"\"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_lower_x_escapes","expr":"b' \\x00 \\x0A \\x7F \\xFF '","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_lower_x_escapes","expr":"b\" \\x00 \\x0A \\x7F \\xFF \"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_lower_x_escapes","expr":"b''' \\x00 \\x0A \\x7F \\xFF '''","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_lower_x_escapes","expr":"b\"\"\" \\x00 \\x0A \\x7F \\xFF \"\"\"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"single_quoted_upper_x_escapes","expr":"b' \\X00 \\X0A \\X7F \\XFF '","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"double_quoted_upper_x_escapes","expr":"b\" \\X00 \\X0A \\X7F \\XFF \"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_single_quoted_upper_x_escapes","expr":"b''' \\X00 \\X0A \\X7F \\XFF '''","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"triple_double_quoted_upper_x_escapes","expr":"b\"\"\" \\X00 \\X0A \\X7F \\XFF \"\"\"","value":{"bytesValue":"IAAgCiB/IP8g"}},"ast":"b\" \\x00 \\n \\x7f \\xff \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\x00 \\n \\x7f \\xff \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_single_quoted_escapes","expr":"B' \\x4a \\x4B \\X4c \\X4D '","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_double_quoted_escapes","expr":"B\" \\x4a \\x4B \\X4c \\X4D \"","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_triple_single_quoted_escapes","expr":"B''' \\x4a \\x4B \\X4c \\X4D '''","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"mixed_case_hex_triple_double_quoted_escapes","expr":"B\"\"\" \\x4a \\x4B \\X4c \\X4D \"\"\"","value":{"bytesValue":"IEogSyBMIE0g"}},"ast":"b\" J K L M \"^#*expr.Constant_BytesValue#","checkedAst":"b\" J K L M \"~bytes","type":"bytes"},{"original":{"name":"raw_single_quoted_escapes","expr":"br' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"bytesValue":"IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"raw_double_quoted_escapes","expr":"br\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"bytesValue":"IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"raw_triple_single_quoted_escapes","expr":"br''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"raw_triple_double_quoted_escapes","expr":"br\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_single_quoted_escapes","expr":"bR' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '","value":{"bytesValue":"IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_double_quoted_escapes","expr":"bR\" \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"","value":{"bytesValue":"IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_triple_single_quoted_escapes","expr":"bR''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"},{"original":{"name":"upper_raw_triple_double_quoted_escapes","expr":"bR\"\"\" \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 \"\"\"","value":{"bytesValue":"IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA=="}},"ast":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"^#*expr.Constant_BytesValue#","checkedAst":"b\" \\\\\\\\ \\\\? \\\\\\\" \\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 \"~bytes","type":"bytes"}]},{"name":"whitespace","tests":[{"original":{"name":"spaces","description":"Check that spaces are ignored.","expr":"[ . cel. expr .conformance. proto3. TestAllTypes { single_int64 : int ( 17 ) } . single_int64 ] [ 0 ] == ( 18 - 1 ) \u0026\u0026 ! false ? 1 : 2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"tabs","description":"Check that tabs (`\\t`) are ignored.","expr":"[\t.\tcel.\texpr\t.conformance.\tproto3.\tTestAllTypes\t{\tsingle_int64\t:\tint\t(\t17\t)\t}\t.\tsingle_int64\t]\t[\t0\t]\t==\t(\t18\t-\t1\t)\t\u0026\u0026\t!\tfalse\t?\t1\t:\t2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"new_lines","description":"Check that new lines (`\\n`) are ignored.","expr":"[\n.\ncel.\nexpr\n.conformance.\nproto3.\nTestAllTypes\n{\nsingle_int64\n:\nint\n(\n17\n)\n}\n.\nsingle_int64\n]\n[\n0\n]\n==\n(\n18\n-\n1\n)\n\u0026\u0026\n!\nfalse\n?\n1\n:\n2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"new_pages","description":"Check that new pages (`\\f`) are ignored.","expr":"[\f.\fcel.\fexpr\f.conformance.\fproto3.\fTestAllTypes\f{\fsingle_int64\f:\fint\f(\f17\f)\f}\f.\fsingle_int64\f]\f[\f0\f]\f==\f(\f18\f-\f1\f)\f\u0026\u0026\f!\ffalse\f?\f1\f:\f2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"},{"original":{"name":"carriage_returns","description":"Check that carriage returns (`\\r`) are ignored.","expr":"[\r.\rcel.\rexpr\r.conformance.\rproto3.\rTestAllTypes\r{\rsingle_int64\r:\rint\r(\r17\r)\r}\r.\rsingle_int64\r]\r[\r0\r]\r==\r(\r18\r-\r1\r)\r\u0026\u0026\r!\rfalse\r?\r1\r:\r2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"}]},{"name":"comments","tests":[{"original":{"name":"new_line_terminated","description":"Check that new-line-terminated comments are ignored.","expr":"[// @\n.// @\ncel.// @\nexpr// @\n.conformance.// @\nproto3.// @\nTestAllTypes// @\n{// @\nsingle_int64// @\n:// @\nint// @\n(// @\n17// @\n)// @\n}// @\n.// @\nsingle_int64// @\n]// @\n[// @\n0// @\n]// @\n==// @\n(// @\n18// @\n-// @\n1// @\n)// @\n\u0026\u0026// @\n!// @\nfalse// @\n?// @\n1// @\n:// @\n2","value":{"int64Value":"1"}},"ast":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional","type":"int"}]},{"name":"selectors","tests":[{"original":{"name":"as","description":"Check that `as` can be used as a selector.","expr":"{ 'as': 1 }.as","value":{"int64Value":"1"}},"ast":"{\n \"as\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.as^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"as\"~string:1~int\n}~map(string, int).as~int","type":"int"},{"original":{"name":"break","description":"Check that `break` can be used as a selector.","expr":"{ 'break': 1 }.break","value":{"int64Value":"1"}},"ast":"{\n \"break\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.break^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"break\"~string:1~int\n}~map(string, int).break~int","type":"int"},{"original":{"name":"const","description":"Check that `const` can be used as a selector.","expr":"{ 'const': 1 }.const","value":{"int64Value":"1"}},"ast":"{\n \"const\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.const^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"const\"~string:1~int\n}~map(string, int).const~int","type":"int"},{"original":{"name":"continue","description":"Check that `continue` can be used as a selector.","expr":"{ 'continue': 1 }.continue","value":{"int64Value":"1"}},"ast":"{\n \"continue\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.continue^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"continue\"~string:1~int\n}~map(string, int).continue~int","type":"int"},{"original":{"name":"else","description":"Check that `else` can be used as a selector.","expr":"{ 'else': 1 }.else","value":{"int64Value":"1"}},"ast":"{\n \"else\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.else^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"else\"~string:1~int\n}~map(string, int).else~int","type":"int"},{"original":{"name":"for","description":"Check that `for` can be used as a selector.","expr":"{ 'for': 1 }.for","value":{"int64Value":"1"}},"ast":"{\n \"for\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.for^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"for\"~string:1~int\n}~map(string, int).for~int","type":"int"},{"original":{"name":"function","description":"Check that `function` can be used as a selector.","expr":"{ 'function': 1 }.function","value":{"int64Value":"1"}},"ast":"{\n \"function\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.function^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"function\"~string:1~int\n}~map(string, int).function~int","type":"int"},{"original":{"name":"if","description":"Check that `if` can be used as a selector.","expr":"{ 'if': 1 }.if","value":{"int64Value":"1"}},"ast":"{\n \"if\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.if^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"if\"~string:1~int\n}~map(string, int).if~int","type":"int"},{"original":{"name":"import","description":"Check that `import` can be used as a selector.","expr":"{ 'import': 1 }.import","value":{"int64Value":"1"}},"ast":"{\n \"import\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.import^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"import\"~string:1~int\n}~map(string, int).import~int","type":"int"},{"original":{"name":"let","description":"Check that `let` can be used as a selector.","expr":"{ 'let': 1 }.let","value":{"int64Value":"1"}},"ast":"{\n \"let\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.let^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"let\"~string:1~int\n}~map(string, int).let~int","type":"int"},{"original":{"name":"loop","description":"Check that `loop` can be used as a selector.","expr":"{ 'loop': 1 }.loop","value":{"int64Value":"1"}},"ast":"{\n \"loop\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.loop^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"loop\"~string:1~int\n}~map(string, int).loop~int","type":"int"},{"original":{"name":"package","description":"Check that `package` can be used as a selector.","expr":"{ 'package': 1 }.package","value":{"int64Value":"1"}},"ast":"{\n \"package\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.package^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"package\"~string:1~int\n}~map(string, int).package~int","type":"int"},{"original":{"name":"namespace","description":"Check that `namespace` can be used as a selector.","expr":"{ 'namespace': 1 }.namespace","value":{"int64Value":"1"}},"ast":"{\n \"namespace\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.namespace^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"namespace\"~string:1~int\n}~map(string, int).namespace~int","type":"int"},{"original":{"name":"return","description":"Check that `return` can be used as a selector.","expr":"{ 'return': 1 }.return","value":{"int64Value":"1"}},"ast":"{\n \"return\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.return^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"return\"~string:1~int\n}~map(string, int).return~int","type":"int"},{"original":{"name":"var","description":"Check that `var` can be used as a selector.","expr":"{ 'var': 1 }.var","value":{"int64Value":"1"}},"ast":"{\n \"var\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.var^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"var\"~string:1~int\n}~map(string, int).var~int","type":"int"},{"original":{"name":"void","description":"Check that `void` can be used as a selector.","expr":"{ 'void': 1 }.void","value":{"int64Value":"1"}},"ast":"{\n \"void\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.void^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"void\"~string:1~int\n}~map(string, int).void~int","type":"int"},{"original":{"name":"while","description":"Check that `while` can be used as a selector.","expr":"{ 'while': 1 }.while","value":{"int64Value":"1"}},"ast":"{\n \"while\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.while^#*expr.Expr_SelectExpr#","checkedAst":"{\n \"while\"~string:1~int\n}~map(string, int).while~int","type":"int"}]},{"name":"receiver_function_names","tests":[{"original":{"name":"as","description":"Check that `as` can be used as a receiver function.","expr":"a.as() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.as()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.as() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'as' (in container '')\n | a.as() || true\n | ....^"},{"original":{"name":"break","description":"Check that `break` can be used as a receiver function.","expr":"a.break() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.break()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.break() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'break' (in container '')\n | a.break() || true\n | .......^"},{"original":{"name":"const","description":"Check that `const` can be used as a receiver function.","expr":"a.const() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.const()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.const() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'const' (in container '')\n | a.const() || true\n | .......^"},{"original":{"name":"continue","description":"Check that `continue` can be used as a receiver function.","expr":"a.continue() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.continue()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.continue() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'continue' (in container '')\n | a.continue() || true\n | ..........^"},{"original":{"name":"else","description":"Check that `else` can be used as a receiver function.","expr":"a.else() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.else()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.else() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'else' (in container '')\n | a.else() || true\n | ......^"},{"original":{"name":"for","description":"Check that `for` can be used as a receiver function.","expr":"a.for() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.for()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.for() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'for' (in container '')\n | a.for() || true\n | .....^"},{"original":{"name":"function","description":"Check that `function` can be used as a receiver function.","expr":"a.function() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.function()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.function() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'function' (in container '')\n | a.function() || true\n | ..........^"},{"original":{"name":"if","description":"Check that `if` can be used as a receiver function.","expr":"a.if() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.if()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.if() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'if' (in container '')\n | a.if() || true\n | ....^"},{"original":{"name":"import","description":"Check that `import` can be used as a receiver function.","expr":"a.import() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.import()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.import() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'import' (in container '')\n | a.import() || true\n | ........^"},{"original":{"name":"let","description":"Check that `let` can be used as a receiver function.","expr":"a.let() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.let()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.let() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'let' (in container '')\n | a.let() || true\n | .....^"},{"original":{"name":"loop","description":"Check that `loop` can be used as a receiver function.","expr":"a.loop() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.loop()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.loop() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'loop' (in container '')\n | a.loop() || true\n | ......^"},{"original":{"name":"package","description":"Check that `package` can be used as a receiver function.","expr":"a.package() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.package()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.package() || true\n | ^\nERROR: \u003cinput\u003e:1:10: undeclared reference to 'package' (in container '')\n | a.package() || true\n | .........^"},{"original":{"name":"namespace","description":"Check that `namespace` can be used as a receiver function.","expr":"a.namespace() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.namespace()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.namespace() || true\n | ^\nERROR: \u003cinput\u003e:1:12: undeclared reference to 'namespace' (in container '')\n | a.namespace() || true\n | ...........^"},{"original":{"name":"return","description":"Check that `return` can be used as a receiver function.","expr":"a.return() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.return()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.return() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'return' (in container '')\n | a.return() || true\n | ........^"},{"original":{"name":"var","description":"Check that `var` can be used as a receiver function.","expr":"a.var() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.var()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.var() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'var' (in container '')\n | a.var() || true\n | .....^"},{"original":{"name":"void","description":"Check that `void` can be used as a receiver function.","expr":"a.void() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.void()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.void() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'void' (in container '')\n | a.void() || true\n | ......^"},{"original":{"name":"while","description":"Check that `while` can be used as a receiver function.","expr":"a.while() || true","disableCheck":true,"value":{"boolValue":true}},"ast":"_||_(\n a^#*expr.Expr_IdentExpr#.while()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.while() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'while' (in container '')\n | a.while() || true\n | .......^"}]},{"name":"struct_field_names","tests":[{"original":{"name":"as","description":"Check that `as` can be used as a struct field name.","expr":"TestAllTypes{ as: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","as":true}}},"ast":"TestAllTypes{\n as:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n as:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"break","description":"Check that `break` can be used as a struct field name.","expr":"TestAllTypes{ break: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","break":true}}},"ast":"TestAllTypes{\n break:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n break:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"const","description":"Check that `const` can be used as a struct field name.","expr":"TestAllTypes{ const: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","const":true}}},"ast":"TestAllTypes{\n const:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n const:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"continue","description":"Check that `continue` can be used as a struct field name.","expr":"TestAllTypes{ continue: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","continue":true}}},"ast":"TestAllTypes{\n continue:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n continue:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"else","description":"Check that `else` can be used as a struct field name.","expr":"TestAllTypes{ else: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","else":true}}},"ast":"TestAllTypes{\n else:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n else:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"for","description":"Check that `for` can be used as a struct field name.","expr":"TestAllTypes{ for: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","for":true}}},"ast":"TestAllTypes{\n for:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n for:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"function","description":"Check that `function` can be used as a struct field name.","expr":"TestAllTypes{ function: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","function":true}}},"ast":"TestAllTypes{\n function:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n function:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"if","description":"Check that `if` can be used as a struct field name.","expr":"TestAllTypes{ if: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","if":true}}},"ast":"TestAllTypes{\n if:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n if:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"import","description":"Check that `import` can be used as a struct field name.","expr":"TestAllTypes{ import: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","import":true}}},"ast":"TestAllTypes{\n import:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n import:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"let","description":"Check that `let` can be used as a struct field name.","expr":"TestAllTypes{ let: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","let":true}}},"ast":"TestAllTypes{\n let:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n let:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"loop","description":"Check that `loop` can be used as a struct field name.","expr":"TestAllTypes{ loop: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","loop":true}}},"ast":"TestAllTypes{\n loop:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n loop:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"package","description":"Check that `package` can be used as a struct field name.","expr":"TestAllTypes{ package: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","package":true}}},"ast":"TestAllTypes{\n package:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n package:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"namespace","description":"Check that `namespace` can be used as a struct field name.","expr":"TestAllTypes{ namespace: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","namespace":true}}},"ast":"TestAllTypes{\n namespace:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n namespace:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"return","description":"Check that `return` can be used as a struct field name.","expr":"TestAllTypes{ return: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","return":true}}},"ast":"TestAllTypes{\n return:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n return:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"var","description":"Check that `var` can be used as a struct field name.","expr":"TestAllTypes{ var: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","var":true}}},"ast":"TestAllTypes{\n var:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n var:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"void","description":"Check that `void` can be used as a struct field name.","expr":"TestAllTypes{ void: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","void":true}}},"ast":"TestAllTypes{\n void:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n void:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"while","description":"Check that `while` can be used as a struct field name.","expr":"TestAllTypes{ while: true }","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","while":true}}},"ast":"TestAllTypes{\n while:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n while:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]}]},{"name":"plumbing","suites":[{"name":"min","tests":[{"original":{"name":"min_program","description":"Smallest functionality: expr in, result out.","expr":"17","value":{"int64Value":"17"}},"ast":"17^#*expr.Constant_Int64Value#","checkedAst":"17~int","type":"int"}]},{"name":"eval_results","tests":[{"original":{"name":"error_result","description":"Check that error results go through.","expr":"1 / 0","evalError":{"errors":[{"message":"foo"}]}},"ast":"_/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_/_(\n 1~int,\n 0~int\n)~int^divide_int64","type":"int"},{"original":{"name":"eval_map_results","description":"Check that map literals results are order independent.","expr":"{\"k1\":\"v1\",\"k\":\"v\"}","value":{"mapValue":{"entries":[{"key":{"stringValue":"k"},"value":{"stringValue":"v"}},{"key":{"stringValue":"k1"},"value":{"stringValue":"v1"}}]}}},"ast":"{\n \"k1\"^#*expr.Constant_StringValue#:\"v1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"k\"^#*expr.Constant_StringValue#:\"v\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"{\n \"k1\"~string:\"v1\"~string,\n \"k\"~string:\"v\"~string\n}~map(string, string)","type":"map(string, string)"}]},{"name":"check_inputs","tests":[{"original":{"name":"skip_check","description":"Make sure we can skip type checking.","expr":"[17, 'pancakes']","disableCheck":true,"value":{"listValue":{"values":[{"int64Value":"17"},{"stringValue":"pancakes"}]}}},"ast":"[\n 17^#*expr.Constant_Int64Value#,\n \"pancakes\"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n 17~int,\n \"pancakes\"~string\n]~list(dyn)","type":"list(dyn)"}]},{"name":"eval_inputs","tests":[{"original":{"name":"one_ignored_value_arg","description":"Check that value bindings can be given, even if ignored.","expr":"'foo'","bindings":{"x":{"value":{"int64Value":"17"}}},"value":{"stringValue":"foo"}},"ast":"\"foo\"^#*expr.Constant_StringValue#","checkedAst":"\"foo\"~string","type":"string"}]}]},{"name":"proto2","suites":[{"name":"literal_singular","tests":[{"original":{"name":"int64_nocontainer","expr":"cel.expr.conformance.proto2.TestAllTypes{single_int64: 17}","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64":"17"}}},"ast":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int32","expr":"TestAllTypes{single_int32: -34}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":-34}}},"ast":"TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int32_eq_uint","expr":"Int32Value{value: 34} == dyn(UInt64Value{value: 34u})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_int32_eq_uint","expr":"Int32Value{value: 34} == dyn(UInt64Value{value: 18446744073709551615u})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"int32_eq_double","expr":"Int32Value{value: 34} == dyn(DoubleValue{value: 34.0})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_int32_eq_double","expr":"Int32Value{value: 34} == dyn(DoubleValue{value: -9223372036854775809.0})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:-9.223372036854776e+18^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:-9.223372036854776e+18~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"int64","expr":"TestAllTypes{single_int64: 17}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64":"17"}}},"ast":"TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint32","expr":"TestAllTypes{single_uint32: 1u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32":1}}},"ast":"TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint32_eq_int","expr":"UInt32Value{value: 34u} == dyn(Int64Value{value: 34})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_uint32_eq_int","expr":"UInt32Value{value: 34u} == dyn(Int64Value{value: -1})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"uint32_eq_double","expr":"UInt32Value{value: 34u} == dyn(DoubleValue{value: 34.0})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_uint32_eq_double","expr":"UInt32Value{value: 34u} == dyn(DoubleValue{value: 18446744073709551616.0})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:1.8446744073709552e+19^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:1.8446744073709552e+19~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"uint64","expr":"TestAllTypes{single_uint64: 9999u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64":"9999"}}},"ast":"TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sint32","expr":"TestAllTypes{single_sint32: -3}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSint32":-3}}},"ast":"TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sint64","expr":"TestAllTypes{single_sint64: 255}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSint64":"255"}}},"ast":"TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"fixed32","expr":"TestAllTypes{single_fixed32: 43u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFixed32":43}}},"ast":"TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"fixed64","expr":"TestAllTypes{single_fixed64: 1880u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFixed64":"1880"}}},"ast":"TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sfixed32","expr":"TestAllTypes{single_sfixed32: -404}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSfixed32":-404}}},"ast":"TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"sfixed64","expr":"TestAllTypes{single_sfixed64: -1}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleSfixed64":"-1"}}},"ast":"TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"float","expr":"TestAllTypes{single_float: 3.1416}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloat":3.1416}}},"ast":"TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"float_eq_int","expr":"FloatValue{value: 3.0} == dyn(Int64Value{value: 3})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n FloatValue{\n value:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:3~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:3~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_float_eq_int","expr":"FloatValue{value: -1.14} == dyn(Int64Value{value: -1})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n FloatValue{\n value:-1.14^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:-1.14~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"float_eq_uint","expr":"FloatValue{value: 34.0} == dyn(UInt64Value{value: 34u})","container":"google.protobuf","value":{"boolValue":true}},"ast":"_==_(\n FloatValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:34~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"not_float_eq_uint","expr":"FloatValue{value: -1.0} == dyn(UInt64Value{value: 18446744073709551615u})","container":"google.protobuf","value":{"boolValue":false}},"ast":"_==_(\n FloatValue{\n value:-1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.FloatValue{\n value:-1~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals","type":"bool"},{"original":{"name":"double","expr":"TestAllTypes{single_double: 6.022e23}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDouble":6.022e+23}}},"ast":"TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bool","expr":"TestAllTypes{single_bool: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBool":true}}},"ast":"TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"string","expr":"TestAllTypes{single_string: 'foo'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleString":"foo"}}},"ast":"TestAllTypes{\n single_string:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string:\"foo\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bytes","expr":"TestAllTypes{single_bytes: b'\\377'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytes":"/w=="}}},"ast":"TestAllTypes{\n single_bytes:b\"\\xff\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes:b\"\\xff\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"}]},{"name":"literal_wellknown","tests":[{"original":{"name":"any","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 1}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":1}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"duration","expr":"TestAllTypes{single_duration: duration('123s')}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDuration":"123s"}}},"ast":"TestAllTypes{\n single_duration:duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_duration:duration(\n \"123s\"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"timestamp","expr":"TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleTimestamp":"2009-02-13T23:31:30Z"}}},"ast":"TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"struct","expr":"TestAllTypes{single_struct: {'one': 1, 'two': 2}}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStruct":{"one":1,"two":2}}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n \"one\"~string:1~int,\n \"two\"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"value","expr":"TestAllTypes{single_value: 'foo'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleValue":"foo"}}},"ast":"TestAllTypes{\n single_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:\"foo\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int64_wrapper","expr":"TestAllTypes{single_int64_wrapper: -321}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64Wrapper":"-321"}}},"ast":"TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"int32_wrapper","expr":"TestAllTypes{single_int32_wrapper: -456}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32Wrapper":-456}}},"ast":"TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"double_wrapper","expr":"TestAllTypes{single_double_wrapper: 2.71828}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleDoubleWrapper":2.71828}}},"ast":"TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"float_wrapper","expr":"TestAllTypes{single_float_wrapper: 2.99792e8}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleFloatWrapper":299792000}}},"ast":"TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint64_wrapper","expr":"TestAllTypes{single_uint64_wrapper: 8675309u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint64Wrapper":"8675309"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"uint32_wrapper","expr":"TestAllTypes{single_uint32_wrapper: 987u}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleUint32Wrapper":987}}},"ast":"TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"string_wrapper","expr":"TestAllTypes{single_string_wrapper: 'hubba'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleStringWrapper":"hubba"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"hubba\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:\"hubba\"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bool_wrapper","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"},{"original":{"name":"bytes_wrapper","expr":"TestAllTypes{single_bytes_wrapper: b'\\301\\103'}","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleBytesWrapper":"wUM="}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes","type":"cel.expr.conformance.proto2.TestAllTypes"}]},{"name":"singular_bind","tests":[{"original":{"name":"int32","expr":"x.single_int32","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt32":17}}}},"value":{"int64Value":"17"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto2.TestAllTypes^x.single_int32~int","type":"int"},{"original":{"name":"int64","expr":"x.single_int64","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","singleInt64":"-99"}}}},"value":{"int64Value":"-99"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto2.TestAllTypes^x.single_int64~int","type":"int"}]},{"name":"empty_field","tests":[{"original":{"name":"scalar_with_default","expr":"TestAllTypes{}.single_int32","container":"cel.expr.conformance.proto2","value":{"int64Value":"-32"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~int","type":"int"},{"original":{"name":"scalar_no_default","expr":"TestAllTypes{}.single_fixed32","container":"cel.expr.conformance.proto2","value":{"uint64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_fixed32~uint","type":"uint"},{"original":{"name":"nested_message","expr":"TestAllTypes{}.single_nested_message","container":"cel.expr.conformance.proto2","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes.NestedMessage"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage","type":"cel.expr.conformance.proto2.TestAllTypes.NestedMessage"},{"original":{"name":"nested_message_subfield","expr":"TestAllTypes{}.single_nested_message.bb","container":"cel.expr.conformance.proto2","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage.bb~int","type":"int"},{"original":{"name":"wkt","expr":"TestAllTypes{}.single_int64_wrapper","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"repeated_scalar","expr":"TestAllTypes{}.repeated_int64","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int64~list(int)","type":"list(int)"},{"original":{"name":"repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"repeated_nested","expr":"TestAllTypes{}.repeated_nested_message","container":"cel.expr.conformance.proto2","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)","type":"list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)"},{"original":{"name":"map","expr":"TestAllTypes{}.map_string_string","container":"cel.expr.conformance.proto2","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~map(string, string)","type":"map(string, string)"}]},{"name":"has","tests":[{"original":{"name":"undefined","expr":"has(TestAllTypes{}.no_such_field)","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"no_such_field"}]}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^"},{"original":{"name":"repeated_none_implicit","expr":"has(TestAllTypes{}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_none_explicit","expr":"has(TestAllTypes{repeated_int32: []}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_one","expr":"has(TestAllTypes{repeated_int32: [1]}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_many","expr":"has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"map_none_implicit","expr":"has(TestAllTypes{}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_none_explicit","expr":"has(TestAllTypes{map_string_string: {}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one_default","expr":"has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"MT\"^#*expr.Constant_StringValue#:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n \"MT\"~string:\"\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one","expr":"has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_many","expr":"has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:\"dos\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string,\n \"two\"~string:\"dos\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"required","expr":"has(TestRequired{required_int32: 4}.required_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestRequired{\n required_int32:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.required_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestRequired{\n required_int32:4~int\n}~cel.expr.conformance.proto2.TestRequired^cel.expr.conformance.proto2.TestRequired.required_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_unset_no_default","expr":"has(TestAllTypes{}.single_sint32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool","type":"bool"},{"original":{"name":"optional_set_no_default","expr":"has(TestAllTypes{single_sint32: -4}.single_sint32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_sint32:-4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-4~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool","type":"bool"},{"original":{"name":"optional_unset_with_default","expr":"has(TestAllTypes{}.single_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_set_with_default","expr":"has(TestAllTypes{single_int32: 16}.single_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_set_to_default","expr":"has(TestAllTypes{single_int32: -32}.single_int32)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_int32:-32^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-32~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"optional_message_unset","expr":"has(TestAllTypes{}.standalone_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"optional_message_set","expr":"has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"optional_enum_unset","expr":"has(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"optional_enum_set","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"optional_enum_set_zero","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"oneof_unset","expr":"has(TestAllTypes{}.single_nested_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_other_set","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set","expr":"has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set_default","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_enum~test-only~~bool","type":"bool"}]},{"name":"set_null","tests":[{"original":{"name":"single_message","expr":"TestAllTypes{single_nested_message: null} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_any","expr":"TestAllTypes{single_any: null}.single_any","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"single_value","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto2","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"single_duration","expr":"TestAllTypes{single_duration: null} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_timestamp","expr":"TestAllTypes{single_timestamp: null} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_scalar","expr":"TestAllTypes{single_bool: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^"},{"original":{"name":"repeated","expr":"TestAllTypes{repeated_int32: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^"},{"original":{"name":"map","expr":"TestAllTypes{map_string_string: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^"},{"original":{"name":"list_value","expr":"TestAllTypes{list_value: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^"},{"original":{"name":"single_struct","expr":"TestAllTypes{single_struct: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto2","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^"}]},{"name":"quoted_fields","tests":[{"original":{"name":"set_field_with_quoted_name","expr":"TestAllTypes{`in`: true} == TestAllTypes{}","container":"cel.expr.conformance.proto2","value":{"boolValue":false}},"error":"ERROR: set_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^"},{"original":{"name":"get_field_with_quoted_name","expr":"TestAllTypes{`in`: true}.`in`","container":"cel.expr.conformance.proto2","value":{"boolValue":true}},"error":"ERROR: get_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field_with_quoted_name:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^"}]},{"name":"extensions_has","tests":[{"original":{"name":"package_scoped_int32","expr":"has(msg.`cel.expr.conformance.proto2.int32_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"error":"ERROR: package_scoped_int32:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.int32_ext`)\n | ........^"},{"original":{"name":"package_scoped_nested_ext","expr":"has(msg.`cel.expr.conformance.proto2.nested_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"error":"ERROR: package_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_ext`)\n | ........^"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"error":"ERROR: package_scoped_test_all_types_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)\n | ........^"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: package_scoped_test_all_types_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)\n | ........^"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: package_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)\n | ........^"},{"original":{"name":"message_scoped_int64","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"error":"ERROR: message_scoped_int64:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)\n | ........^"},{"original":{"name":"message_scoped_nested_ext","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"error":"ERROR: message_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)\n | ........^"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: message_scoped_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)\n | ........^"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: message_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)\n | ........^"}]},{"name":"extensions_get","tests":[{"original":{"name":"package_scoped_int32","expr":"msg.`cel.expr.conformance.proto2.int32_ext` == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"error":"ERROR: package_scoped_int32:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.int32_ext` == 42\n | ....^"},{"original":{"name":"package_scoped_nested_ext","expr":"msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"error":"ERROR: package_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"error":"ERROR: package_scoped_test_all_types_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: package_scoped_test_all_types_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: package_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^"},{"original":{"name":"message_scoped_int64","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"error":"ERROR: message_scoped_int64:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42\n | ....^"},{"original":{"name":"message_scoped_nested_ext","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"error":"ERROR: message_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"error":"ERROR: message_scoped_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"error":"ERROR: message_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^"}]}]},{"name":"proto2_ext","suites":[{"name":"has_ext","tests":[{"original":{"name":"package_scoped_int32","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.int32_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_nested_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.nested_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.test_all_types_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.nested_enum_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~test-only~~bool","type":"bool"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.repeated_test_all_types)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_int64","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_nested_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~test-only~~bool","type":"bool"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types)","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~test-only~~bool","type":"bool"}]},{"name":"get_ext","tests":[{"original":{"name":"package_scoped_int32","expr":"proto.getExt(msg, cel.expr.conformance.proto2.int32_ext) == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.int32_ext]":42}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~int,\n 42~int\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_nested_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_ext]":{}}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_test_all_types_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.test_all_types_ext) == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.test_all_types_ext]":{}}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_test_all_types_nested_enum_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.nested_enum_ext]":"BAR"}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals","type":"bool"},{"original":{"name":"package_scoped_repeated_test_all_types","expr":"proto.getExt(msg, cel.expr.conformance.proto2.repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_int64","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext) == 42","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]":"42"}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~int,\n 42~int\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_nested_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]":{}}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_nested_enum_ext","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]":"BAR"}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals","type":"bool"},{"original":{"name":"message_scoped_repeated_test_all_types","expr":"proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto2.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes","[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]":[{"singleInt64":"1"},{"singleBool":true}]}}}}},"ast":"_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals","type":"bool"}]}]},{"name":"proto3","suites":[{"name":"literal_singular","tests":[{"original":{"name":"int64_nocontainer","expr":"cel.expr.conformance.proto3.TestAllTypes{single_int64: 17}","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"17"}}},"ast":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int32","expr":"TestAllTypes{single_int32: -34}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":-34}}},"ast":"TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int64","expr":"TestAllTypes{single_int64: 17}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"17"}}},"ast":"TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint32","expr":"TestAllTypes{single_uint32: 1u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32":1}}},"ast":"TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint64","expr":"TestAllTypes{single_uint64: 9999u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64":"9999"}}},"ast":"TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sint32","expr":"TestAllTypes{single_sint32: -3}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSint32":-3}}},"ast":"TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sint64","expr":"TestAllTypes{single_sint64: 255}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSint64":"255"}}},"ast":"TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"fixed32","expr":"TestAllTypes{single_fixed32: 43u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFixed32":43}}},"ast":"TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"fixed64","expr":"TestAllTypes{single_fixed64: 1880u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFixed64":"1880"}}},"ast":"TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sfixed32","expr":"TestAllTypes{single_sfixed32: -404}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSfixed32":-404}}},"ast":"TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"sfixed64","expr":"TestAllTypes{single_sfixed64: -1}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleSfixed64":"-1"}}},"ast":"TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"float","expr":"TestAllTypes{single_float: 3.1416}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloat":3.1416}}},"ast":"TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"double","expr":"TestAllTypes{single_double: 6.022e23}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDouble":6.022e+23}}},"ast":"TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bool","expr":"TestAllTypes{single_bool: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBool":true}}},"ast":"TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"string","expr":"TestAllTypes{single_string: 'foo'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleString":"foo"}}},"ast":"TestAllTypes{\n single_string:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string:\"foo\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bytes","expr":"TestAllTypes{single_bytes: b'\\377'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytes":"/w=="}}},"ast":"TestAllTypes{\n single_bytes:b\"\\xff\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes:b\"\\xff\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"literal_wellknown","tests":[{"original":{"name":"any","expr":"TestAllTypes{single_any: TestAllTypes{single_int32: 1}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleAny":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":1}}}},"ast":"TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"duration","expr":"TestAllTypes{single_duration: duration('123s')}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDuration":"123s"}}},"ast":"TestAllTypes{\n single_duration:duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_duration:duration(\n \"123s\"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"timestamp","expr":"TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleTimestamp":"2009-02-13T23:31:30Z"}}},"ast":"TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"struct","expr":"TestAllTypes{single_struct: {'one': 1, 'two': 2}}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStruct":{"one":1,"two":2}}}},"ast":"TestAllTypes{\n single_struct:{\n \"one\"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n \"one\"~string:1~int,\n \"two\"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"value","expr":"TestAllTypes{single_value: 'foo'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleValue":"foo"}}},"ast":"TestAllTypes{\n single_value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:\"foo\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int64_wrapper","expr":"TestAllTypes{single_int64_wrapper: -321}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64Wrapper":"-321"}}},"ast":"TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"int32_wrapper","expr":"TestAllTypes{single_int32_wrapper: -456}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32Wrapper":-456}}},"ast":"TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"double_wrapper","expr":"TestAllTypes{single_double_wrapper: 2.71828}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleDoubleWrapper":2.71828}}},"ast":"TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"float_wrapper","expr":"TestAllTypes{single_float_wrapper: 2.99792e8}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleFloatWrapper":299792000}}},"ast":"TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint64_wrapper","expr":"TestAllTypes{single_uint64_wrapper: 8675309u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint64Wrapper":"8675309"}}},"ast":"TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"uint32_wrapper","expr":"TestAllTypes{single_uint32_wrapper: 987u}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleUint32Wrapper":987}}},"ast":"TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"string_wrapper","expr":"TestAllTypes{single_string_wrapper: 'hubba'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleStringWrapper":"hubba"}}},"ast":"TestAllTypes{\n single_string_wrapper:\"hubba\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:\"hubba\"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bool_wrapper","expr":"TestAllTypes{single_bool_wrapper: true}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBoolWrapper":true}}},"ast":"TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"},{"original":{"name":"bytes_wrapper","expr":"TestAllTypes{single_bytes_wrapper: b'\\301\\103'}","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleBytesWrapper":"wUM="}}},"ast":"TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b\"\\xc1C\"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"singular_bind","tests":[{"original":{"name":"int32","expr":"x.single_int32","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt32":17}}}},"value":{"int64Value":"17"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32~int","type":"int"},{"original":{"name":"int64","expr":"x.single_int64","typeEnv":[{"name":"x","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"-99"}}}},"value":{"int64Value":"-99"}},"ast":"x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64~int","type":"int"}]},{"name":"empty_field","tests":[{"original":{"name":"scalar","expr":"TestAllTypes{}.single_fixed32","container":"cel.expr.conformance.proto3","value":{"uint64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_fixed32~uint","type":"uint"},{"original":{"name":"nested_message","expr":"TestAllTypes{}.single_nested_message","container":"cel.expr.conformance.proto3","value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage","type":"cel.expr.conformance.proto3.TestAllTypes.NestedMessage"},{"original":{"name":"nested_message_subfield","expr":"TestAllTypes{}.single_nested_message.bb","container":"cel.expr.conformance.proto3","value":{"int64Value":"0"}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage.bb~int","type":"int"},{"original":{"name":"wkt","expr":"TestAllTypes{}.single_int64_wrapper","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int)","type":"wrapper(int)"},{"original":{"name":"repeated_scalar","expr":"TestAllTypes{}.repeated_int64","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)","type":"list(int)"},{"original":{"name":"repeated_enum","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"repeated_nested","expr":"TestAllTypes{}.repeated_nested_message","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)","type":"list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)"},{"original":{"name":"map","expr":"TestAllTypes{}.map_string_string","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~map(string, string)","type":"map(string, string)"}]},{"name":"has","tests":[{"original":{"name":"undefined","expr":"has(TestAllTypes{}.no_such_field)","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"no_such_field"}]}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#","error":"ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^"},{"original":{"name":"repeated_none_implicit","expr":"has(TestAllTypes{}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_none_explicit","expr":"has(TestAllTypes{repeated_int32: []}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_one","expr":"has(TestAllTypes{repeated_int32: [1]}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"repeated_many","expr":"has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool","type":"bool"},{"original":{"name":"map_none_implicit","expr":"has(TestAllTypes{}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_none_explicit","expr":"has(TestAllTypes{map_string_string: {}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one_default","expr":"has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"MT\"^#*expr.Constant_StringValue#:\"\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n \"MT\"~string:\"\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_one","expr":"has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"map_many","expr":"has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n map_string_string:{\n \"one\"^#*expr.Constant_StringValue#:\"uno\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n \"two\"^#*expr.Constant_StringValue#:\"dos\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n \"one\"~string:\"uno\"~string,\n \"two\"~string:\"dos\"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool","type":"bool"},{"original":{"name":"single_unset","expr":"has(TestAllTypes{}.single_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"single_set","expr":"has(TestAllTypes{single_int32: 16}.single_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"single_set_to_default","expr":"has(TestAllTypes{single_int32: 0}.single_int32)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_int32:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int32:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool","type":"bool"},{"original":{"name":"single_message_unset","expr":"has(TestAllTypes{}.standalone_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"single_message_set","expr":"has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{bb: 123}}.standalone_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{\n bb:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{\n bb:123~int\n }~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"single_message_set_to_default","expr":"has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool","type":"bool"},{"original":{"name":"single_enum_unset","expr":"has(TestAllTypes{}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"single_enum_set","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"single_enum_set_zero","expr":"has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool","type":"bool"},{"original":{"name":"oneof_unset","expr":"has(TestAllTypes{}.single_nested_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_other_set","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set","expr":"has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool","type":"bool"},{"original":{"name":"oneof_set_default","expr":"has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_enum~test-only~~bool","type":"bool"}]},{"name":"set_null","tests":[{"original":{"name":"single_message","expr":"TestAllTypes{single_nested_message: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_any","expr":"TestAllTypes{single_any: null}.single_any","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"single_value","expr":"TestAllTypes{single_value: null}.single_value","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"single_duration","expr":"TestAllTypes{single_duration: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_timestamp","expr":"TestAllTypes{single_timestamp: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"},{"original":{"name":"single_scalar","expr":"TestAllTypes{single_bool: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^"},{"original":{"name":"repeated","expr":"TestAllTypes{repeated_int32: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^"},{"original":{"name":"map","expr":"TestAllTypes{map_string_string: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^"},{"original":{"name":"list_value","expr":"TestAllTypes{list_value: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^"},{"original":{"name":"single_struct","expr":"TestAllTypes{single_struct: null} == TestAllTypes{}","disableCheck":true,"container":"cel.expr.conformance.proto3","evalError":{"errors":[{"message":"unsupported field type"}]}},"ast":"_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^"}]},{"name":"quoted_fields","tests":[{"original":{"name":"set_field","expr":"TestAllTypes{`in`: true} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":false}},"error":"ERROR: set_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^"},{"original":{"name":"get_field","expr":"TestAllTypes{`in`: true}.`in`","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"error":"ERROR: get_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^"}]}]},{"name":"string","suites":[{"name":"size","tests":[{"original":{"name":"empty","expr":"size('')","value":{"int64Value":"0"}},"ast":"size(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"\"~string\n)~int^size_string","type":"int"},{"original":{"name":"one_ascii","expr":"size('A')","value":{"int64Value":"1"}},"ast":"size(\n \"A\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"A\"~string\n)~int^size_string","type":"int"},{"original":{"name":"one_unicode","expr":"size('ÿ')","value":{"int64Value":"1"}},"ast":"size(\n \"ÿ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"ÿ\"~string\n)~int^size_string","type":"int"},{"original":{"name":"ascii","expr":"size('four')","value":{"int64Value":"4"}},"ast":"size(\n \"four\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"four\"~string\n)~int^size_string","type":"int"},{"original":{"name":"unicode","expr":"size('πέντε')","value":{"int64Value":"5"}},"ast":"size(\n \"πέντε\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n \"πέντε\"~string\n)~int^size_string","type":"int"},{"original":{"name":"bytes_empty","expr":"size(b'')","value":{"int64Value":"0"}},"ast":"size(\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n b\"\"~bytes\n)~int^size_bytes","type":"int"},{"original":{"name":"bytes","expr":"size(b'abc')","value":{"int64Value":"3"}},"ast":"size(\n b\"abc\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"size(\n b\"abc\"~bytes\n)~int^size_bytes","type":"int"}]},{"name":"starts_with","tests":[{"original":{"name":"basic_true","expr":"'foobar'.startsWith('foo')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.startsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.startsWith(\n \"foo\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"basic_false","expr":"'foobar'.startsWith('bar')","value":{"boolValue":false}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.startsWith(\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.startsWith(\n \"bar\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"empty_target","expr":"''.startsWith('foo')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.startsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.startsWith(\n \"foo\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"empty_arg","expr":"'foobar'.startsWith('')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.startsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.startsWith(\n \"\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.startsWith('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.startsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.startsWith(\n \"\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"unicode","expr":"'завтра'.startsWith('за')","value":{"boolValue":true}},"ast":"\"завтра\"^#*expr.Constant_StringValue#.startsWith(\n \"за\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"завтра\"~string.startsWith(\n \"за\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"unicode_smp","expr":"'🐱😀😛'.startsWith('🐱')","value":{"boolValue":true}},"ast":"\"🐱😀😛\"^#*expr.Constant_StringValue#.startsWith(\n \"🐱\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😛\"~string.startsWith(\n \"🐱\"~string\n)~bool^starts_with_string","type":"bool"}]},{"name":"ends_with","tests":[{"original":{"name":"basic_true","expr":"'foobar'.endsWith('bar')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.endsWith(\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.endsWith(\n \"bar\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"basic_false","expr":"'foobar'.endsWith('foo')","value":{"boolValue":false}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.endsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.endsWith(\n \"foo\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"empty_target","expr":"''.endsWith('foo')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.endsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.endsWith(\n \"foo\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"empty_arg","expr":"'foobar'.endsWith('')","value":{"boolValue":true}},"ast":"\"foobar\"^#*expr.Constant_StringValue#.endsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"foobar\"~string.endsWith(\n \"\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.endsWith('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.endsWith(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.endsWith(\n \"\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"unicode","expr":"'forté'.endsWith('té')","value":{"boolValue":true}},"ast":"\"forté\"^#*expr.Constant_StringValue#.endsWith(\n \"té\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"forté\"~string.endsWith(\n \"té\"~string\n)~bool^ends_with_string","type":"bool"},{"original":{"name":"unicode_smp","expr":"'🐱😀😛'.endsWith('😛')","value":{"boolValue":true}},"ast":"\"🐱😀😛\"^#*expr.Constant_StringValue#.endsWith(\n \"😛\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😛\"~string.endsWith(\n \"😛\"~string\n)~bool^ends_with_string","type":"bool"}]},{"name":"matches","tests":[{"original":{"name":"basic","expr":"'hubba'.matches('ubb')","value":{"boolValue":true}},"ast":"\"hubba\"^#*expr.Constant_StringValue#.matches(\n \"ubb\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hubba\"~string.matches(\n \"ubb\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"empty_target","expr":"''.matches('foo|bar')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.matches(\n \"foo|bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.matches(\n \"foo|bar\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"empty_arg","expr":"'cows'.matches('')","value":{"boolValue":true}},"ast":"\"cows\"^#*expr.Constant_StringValue#.matches(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"cows\"~string.matches(\n \"\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.matches('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.matches(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.matches(\n \"\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"re_concat","expr":"'abcd'.matches('bc')","value":{"boolValue":true}},"ast":"\"abcd\"^#*expr.Constant_StringValue#.matches(\n \"bc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"abcd\"~string.matches(\n \"bc\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"re_alt","expr":"'grey'.matches('gr(a|e)y')","value":{"boolValue":true}},"ast":"\"grey\"^#*expr.Constant_StringValue#.matches(\n \"gr(a|e)y\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"grey\"~string.matches(\n \"gr(a|e)y\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"re_rep","expr":"'banana'.matches('ba(na)*')","value":{"boolValue":true}},"ast":"\"banana\"^#*expr.Constant_StringValue#.matches(\n \"ba(na)*\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"banana\"~string.matches(\n \"ba(na)*\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"unicode","expr":"'mañana'.matches('a+ñ+a+')","value":{"boolValue":true}},"ast":"\"mañana\"^#*expr.Constant_StringValue#.matches(\n \"a+ñ+a+\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"mañana\"~string.matches(\n \"a+ñ+a+\"~string\n)~bool^matches_string","type":"bool"},{"original":{"name":"unicode_smp","expr":"'🐱😀😀'.matches('(a|😀){2}')","value":{"boolValue":true}},"ast":"\"🐱😀😀\"^#*expr.Constant_StringValue#.matches(\n \"(a|😀){2}\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😀\"~string.matches(\n \"(a|😀){2}\"~string\n)~bool^matches_string","type":"bool"}]},{"name":"concatenation","tests":[{"original":{"name":"concat_true","expr":"'he' + 'llo'","value":{"stringValue":"hello"}},"ast":"_+_(\n \"he\"^#*expr.Constant_StringValue#,\n \"llo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"he\"~string,\n \"llo\"~string\n)~string^add_string","type":"string"},{"original":{"name":"concat_with_spaces","expr":"'hello' + ' ' == 'hello'","value":{"boolValue":false}},"ast":"_==_(\n _+_(\n \"hello\"^#*expr.Constant_StringValue#,\n \" \"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"hello\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n \"hello\"~string,\n \" \"~string\n )~string^add_string,\n \"hello\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"concat_empty_string_beginning","expr":"'' + 'abc'","value":{"stringValue":"abc"}},"ast":"_+_(\n \"\"^#*expr.Constant_StringValue#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"\"~string,\n \"abc\"~string\n)~string^add_string","type":"string"},{"original":{"name":"concat_empty_string_end","expr":"'abc' + ''","value":{"stringValue":"abc"}},"ast":"_+_(\n \"abc\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"abc\"~string,\n \"\"~string\n)~string^add_string","type":"string"},{"original":{"name":"concat_empty_with_empty","expr":"'' + ''","value":{"stringValue":""}},"ast":"_+_(\n \"\"^#*expr.Constant_StringValue#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"\"~string,\n \"\"~string\n)~string^add_string","type":"string"},{"original":{"name":"unicode_unicode","expr":"'¢' + 'ÿ' + 'Ȁ'","value":{"stringValue":"¢ÿȀ"}},"ast":"_+_(\n _+_(\n \"¢\"^#*expr.Constant_StringValue#,\n \"ÿ\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"Ȁ\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"¢\"~string,\n \"ÿ\"~string\n )~string^add_string,\n \"Ȁ\"~string\n)~string^add_string","type":"string"},{"original":{"name":"ascii_unicode","expr":"'r' + 'ô' + 'le'","value":{"stringValue":"rôle"}},"ast":"_+_(\n _+_(\n \"r\"^#*expr.Constant_StringValue#,\n \"ô\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"le\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"r\"~string,\n \"ô\"~string\n )~string^add_string,\n \"le\"~string\n)~string^add_string","type":"string"},{"original":{"name":"ascii_unicode_unicode_smp","expr":"'a' + 'ÿ' + '🐱'","value":{"stringValue":"aÿ🐱"}},"ast":"_+_(\n _+_(\n \"a\"^#*expr.Constant_StringValue#,\n \"ÿ\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"🐱\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"a\"~string,\n \"ÿ\"~string\n )~string^add_string,\n \"🐱\"~string\n)~string^add_string","type":"string"},{"original":{"name":"empty_unicode","expr":"'' + 'Ω' + ''","value":{"stringValue":"Ω"}},"ast":"_+_(\n _+_(\n \"\"^#*expr.Constant_StringValue#,\n \"Ω\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n _+_(\n \"\"~string,\n \"Ω\"~string\n )~string^add_string,\n \"\"~string\n)~string^add_string","type":"string"}]},{"name":"contains","tests":[{"original":{"name":"contains_true","expr":"'hello'.contains('he')","value":{"boolValue":true}},"ast":"\"hello\"^#*expr.Constant_StringValue#.contains(\n \"he\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hello\"~string.contains(\n \"he\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_empty","expr":"'hello'.contains('')","value":{"boolValue":true}},"ast":"\"hello\"^#*expr.Constant_StringValue#.contains(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hello\"~string.contains(\n \"\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_false","expr":"'hello'.contains('ol')","value":{"boolValue":false}},"ast":"\"hello\"^#*expr.Constant_StringValue#.contains(\n \"ol\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"hello\"~string.contains(\n \"ol\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_multiple","expr":"'abababc'.contains('ababc')","value":{"boolValue":true}},"ast":"\"abababc\"^#*expr.Constant_StringValue#.contains(\n \"ababc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"abababc\"~string.contains(\n \"ababc\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_unicode","expr":"'Straße'.contains('aß')","value":{"boolValue":true}},"ast":"\"Straße\"^#*expr.Constant_StringValue#.contains(\n \"aß\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"Straße\"~string.contains(\n \"aß\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"contains_unicode_smp","expr":"'🐱😀😁'.contains('😀')","value":{"boolValue":true}},"ast":"\"🐱😀😁\"^#*expr.Constant_StringValue#.contains(\n \"😀\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"🐱😀😁\"~string.contains(\n \"😀\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"empty_contains","expr":"''.contains('something')","value":{"boolValue":false}},"ast":"\"\"^#*expr.Constant_StringValue#.contains(\n \"something\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.contains(\n \"something\"~string\n)~bool^contains_string","type":"bool"},{"original":{"name":"empty_empty","expr":"''.contains('')","value":{"boolValue":true}},"ast":"\"\"^#*expr.Constant_StringValue#.contains(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"\"~string.contains(\n \"\"~string\n)~bool^contains_string","type":"bool"}]},{"name":"bytes_concat","tests":[{"original":{"name":"concat","expr":"b'abc' + b'def'","value":{"bytesValue":"YWJjZGVm"}},"ast":"_+_(\n b\"abc\"^#*expr.Constant_BytesValue#,\n b\"def\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"abc\"~bytes,\n b\"def\"~bytes\n)~bytes^add_bytes","type":"bytes"},{"original":{"name":"left_unit","expr":"b'' + b'\\xffoo'","value":{"bytesValue":"/29v"}},"ast":"_+_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\\xffoo\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"\"~bytes,\n b\"\\xffoo\"~bytes\n)~bytes^add_bytes","type":"bytes"},{"original":{"name":"right_unit","expr":"b'zxy' + b''","value":{"bytesValue":"enh5"}},"ast":"_+_(\n b\"zxy\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"zxy\"~bytes,\n b\"\"~bytes\n)~bytes^add_bytes","type":"bytes"},{"original":{"name":"empty_empty","expr":"b'' + b''","value":{"bytesValue":""}},"ast":"_+_(\n b\"\"^#*expr.Constant_BytesValue#,\n b\"\"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n b\"\"~bytes,\n b\"\"~bytes\n)~bytes^add_bytes","type":"bytes"}]}]},{"name":"string_ext","suites":[{"name":"char_at","tests":[{"original":{"name":"middle_index","expr":"'tacocat'.charAt(3)","value":{"stringValue":"o"}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.charAt(\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.charAt(\n 3~int\n)~string^string_char_at_int","type":"string"},{"original":{"name":"end_index","expr":"'tacocat'.charAt(7)","value":{"stringValue":""}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.charAt(\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.charAt(\n 7~int\n)~string^string_char_at_int","type":"string"},{"original":{"name":"multiple","expr":"'©αT'.charAt(0) == '©' \u0026\u0026 '©αT'.charAt(1) == 'α' \u0026\u0026 '©αT'.charAt(2) == 'T'"},"ast":"_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n \"©αT\"^#*expr.Constant_StringValue#.charAt(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"©\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n \"©αT\"^#*expr.Constant_StringValue#.charAt(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"α\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _==_(\n \"©αT\"^#*expr.Constant_StringValue#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"T\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n \"©αT\"~string.charAt(\n 0~int\n )~string^string_char_at_int,\n \"©\"~string\n )~bool^equals,\n _==_(\n \"©αT\"~string.charAt(\n 1~int\n )~string^string_char_at_int,\n \"α\"~string\n )~bool^equals\n )~bool^logical_and,\n _==_(\n \"©αT\"~string.charAt(\n 2~int\n )~string^string_char_at_int,\n \"T\"~string\n )~bool^equals\n)~bool^logical_and","type":"bool"}]},{"name":"index_of","tests":[{"original":{"name":"empty_index","expr":"'tacocat'.indexOf('')","value":{"int64Value":"0"}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.indexOf(\n \"\"~string\n)~int^string_index_of_string","type":"int"},{"original":{"name":"string_index","expr":"'tacocat'.indexOf('ac')","value":{"int64Value":"1"}},"ast":"\"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"ac\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"tacocat\"~string.indexOf(\n \"ac\"~string\n)~int^string_index_of_string","type":"int"},{"original":{"name":"nomatch","expr":"'tacocat'.indexOf('none') == -1"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"none\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"none\"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"empty_index","expr":"'tacocat'.indexOf('', 3) == 3"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 3~int\n)~bool^equals","type":"bool"},{"original":{"name":"char_index","expr":"'tacocat'.indexOf('a', 3) == 5"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"a\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_index","expr":"'tacocat'.indexOf('at', 3) == 5"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"at\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"at\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char","expr":"'ta©o©αT'.indexOf('©') == 2"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©\"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char_index","expr":"'ta©o©αT'.indexOf('©', 3) == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_string_index","expr":"'ta©o©αT'.indexOf('©αT', 3) == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©αT\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©αT\"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_string_nomatch_index","expr":"'ta©o©αT'.indexOf('©α', 5) == -1"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.indexOf(\n \"©α\"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.indexOf(\n \"©α\"~string,\n 5~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"char_index","expr":"'ijk'.indexOf('k') == 2"},"ast":"_==_(\n \"ijk\"^#*expr.Constant_StringValue#.indexOf(\n \"k\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ijk\"~string.indexOf(\n \"k\"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_fullmatch","expr":"'hello wello'.indexOf('hello wello') == 0"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.indexOf(\n \"hello wello\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.indexOf(\n \"hello wello\"~string\n )~int^string_index_of_string,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_index","expr":"'hello wello'.indexOf('ello', 6) == 7"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.indexOf(\n \"ello\"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.indexOf(\n \"ello\"~string,\n 6~int\n )~int^string_index_of_string_int,\n 7~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_nomatch_index","expr":"'hello wello'.indexOf('elbo room!!') == -1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.indexOf(\n \"elbo room!!\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.indexOf(\n \"elbo room!!\"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals","type":"bool"}]},{"name":"last_index_of","tests":[{"original":{"name":"empty_string","expr":"''.lastIndexOf('@@') == -1"},"ast":"_==_(\n \"\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"@@\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\"~string.lastIndexOf(\n \"@@\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"empty_argument","expr":"'tacocat'.lastIndexOf('') == 7"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"\"~string\n )~int^string_last_index_of_string,\n 7~int\n)~bool^equals","type":"bool"},{"original":{"name":"string","expr":"'tacocat'.lastIndexOf('at') == 5"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"at\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"at\"~string\n )~int^string_last_index_of_string,\n 5~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_nomatch","expr":"'tacocat'.lastIndexOf('none') == -1"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"none\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"none\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"empty_index","expr":"'tacocat'.lastIndexOf('', 3) == 3"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"\"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 3~int\n)~bool^equals","type":"bool"},{"original":{"name":"char_index","expr":"'tacocat'.lastIndexOf('a', 3) == 1"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"a\"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char","expr":"'ta©o©αT'.lastIndexOf('©') == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"©\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.lastIndexOf(\n \"©\"~string\n )~int^string_last_index_of_string,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_char_index","expr":"'ta©o©αT'.lastIndexOf('©', 3) == 2"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"©\"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.lastIndexOf(\n \"©\"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 2~int\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_string_index","expr":"'ta©o©αT'.lastIndexOf('©α', 4) == 4"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"©α\"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.lastIndexOf(\n \"©α\"~string,\n 4~int\n )~int^string_last_index_of_string_int,\n 4~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_string_index","expr":"'hello wello'.lastIndexOf('ello', 6) == 1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"ello\"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"ello\"~string,\n 6~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_string_nomatch","expr":"'hello wello'.lastIndexOf('low') == -1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"low\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"low\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_string_with_space_nomatch","expr":"'hello wello'.lastIndexOf('elbo room!!') == -1"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"elbo room!!\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"elbo room!!\"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"string_with_space_fullmatch","expr":"'hello wello'.lastIndexOf('hello wello') == 0"},"ast":"_==_(\n \"hello wello\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"hello wello\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello wello\"~string.lastIndexOf(\n \"hello wello\"~string\n )~int^string_last_index_of_string,\n 0~int\n)~bool^equals","type":"bool"},{"original":{"name":"repeated_string","expr":"'bananananana'.lastIndexOf('nana', 7) == 6"},"ast":"_==_(\n \"bananananana\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"nana\"^#*expr.Constant_StringValue#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"bananananana\"~string.lastIndexOf(\n \"nana\"~string,\n 7~int\n )~int^string_last_index_of_string_int,\n 6~int\n)~bool^equals","type":"bool"}]},{"name":"ascii_casing","tests":[{"original":{"name":"lowerascii","expr":"'TacoCat'.lowerAscii() == 'tacocat'"},"ast":"_==_(\n \"TacoCat\"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n \"tacocat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCat\"~string.lowerAscii()~string^string_lower_ascii,\n \"tacocat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"lowerascii_unicode","expr":"'TacoCÆt'.lowerAscii() == 'tacocÆt'"},"ast":"_==_(\n \"TacoCÆt\"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n \"tacocÆt\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCÆt\"~string.lowerAscii()~string^string_lower_ascii,\n \"tacocÆt\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"lowerascii_unicode_with_space","expr":"'TacoCÆt Xii'.lowerAscii() == 'tacocÆt xii'"},"ast":"_==_(\n \"TacoCÆt Xii\"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n \"tacocÆt xii\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCÆt Xii\"~string.lowerAscii()~string^string_lower_ascii,\n \"tacocÆt xii\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"upperascii","expr":"'tacoCat'.upperAscii() == 'TACOCAT'"},"ast":"_==_(\n \"tacoCat\"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n \"TACOCAT\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacoCat\"~string.upperAscii()~string^string_upper_ascii,\n \"TACOCAT\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"upperascii_unicode","expr":"'tacoCαt'.upperAscii() == 'TACOCαT'"},"ast":"_==_(\n \"tacoCαt\"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n \"TACOCαT\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacoCαt\"~string.upperAscii()~string^string_upper_ascii,\n \"TACOCαT\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"upperascii_unicode_with_space","expr":"'TacoCÆt Xii'.upperAscii() == 'TACOCÆT XII'"},"ast":"_==_(\n \"TacoCÆt Xii\"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n \"TACOCÆT XII\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"TacoCÆt Xii\"~string.upperAscii()~string^string_upper_ascii,\n \"TACOCÆT XII\"~string\n)~bool^equals","type":"bool"}]},{"name":"replace","tests":[{"original":{"name":"no_placeholder","expr":"'12 days 12 hours'.replace('{0}', '2') == '12 days 12 hours'"},"ast":"_==_(\n \"12 days 12 hours\"^#*expr.Constant_StringValue#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"12 days 12 hours\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"12 days 12 hours\"~string.replace(\n \"{0}\"~string,\n \"2\"~string\n )~string^string_replace_string_string,\n \"12 days 12 hours\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"basic","expr":"'{0} days {0} hours'.replace('{0}', '2') == '2 days 2 hours'"},"ast":"_==_(\n \"{0} days {0} hours\"^#*expr.Constant_StringValue#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"2 days 2 hours\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"{0} days {0} hours\"~string.replace(\n \"{0}\"~string,\n \"2\"~string\n )~string^string_replace_string_string,\n \"2 days 2 hours\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"chained","expr":"'{0} days {0} hours'.replace('{0}', '2', 1).replace('{0}', '23') == '2 days 23 hours'"},"ast":"_==_(\n \"{0} days {0} hours\"^#*expr.Constant_StringValue#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.replace(\n \"{0}\"^#*expr.Constant_StringValue#,\n \"23\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"2 days 23 hours\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"{0} days {0} hours\"~string.replace(\n \"{0}\"~string,\n \"2\"~string,\n 1~int\n )~string^string_replace_string_string_int.replace(\n \"{0}\"~string,\n \"23\"~string\n )~string^string_replace_string_string,\n \"2 days 23 hours\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode","expr":"'1 ©αT taco'.replace('αT', 'o©α') == '1 ©o©α taco'"},"ast":"_==_(\n \"1 ©αT taco\"^#*expr.Constant_StringValue#.replace(\n \"αT\"^#*expr.Constant_StringValue#,\n \"o©α\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"1 ©o©α taco\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"1 ©αT taco\"~string.replace(\n \"αT\"~string,\n \"o©α\"~string\n )~string^string_replace_string_string,\n \"1 ©o©α taco\"~string\n)~bool^equals","type":"bool"}]},{"name":"split","tests":[{"original":{"name":"empty","expr":"'hello world'.split(' ') == ['hello', 'world']"},"ast":"_==_(\n \"hello world\"^#*expr.Constant_StringValue#.split(\n \" \"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"hello\"^#*expr.Constant_StringValue#,\n \"world\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello world\"~string.split(\n \" \"~string\n )~list(string)^string_split_string,\n [\n \"hello\"~string,\n \"world\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"zero_limit","expr":"'hello world events!'.split(' ', 0) == []"},"ast":"_==_(\n \"hello world events!\"^#*expr.Constant_StringValue#.split(\n \" \"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello world events!\"~string.split(\n \" \"~string,\n 0~int\n )~list(string)^string_split_string_int,\n []~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"one_limit","expr":"'hello world events!'.split(' ', 1) == ['hello world events!']"},"ast":"_==_(\n \"hello world events!\"^#*expr.Constant_StringValue#.split(\n \" \"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"hello world events!\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"hello world events!\"~string.split(\n \" \"~string,\n 1~int\n )~list(string)^string_split_string_int,\n [\n \"hello world events!\"~string\n ]~list(string)\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_negative_limit","expr":"'o©o©o©o'.split('©', -1) == ['o', 'o', 'o', 'o']"},"ast":"_==_(\n \"o©o©o©o\"^#*expr.Constant_StringValue#.split(\n \"©\"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"o\"^#*expr.Constant_StringValue#,\n \"o\"^#*expr.Constant_StringValue#,\n \"o\"^#*expr.Constant_StringValue#,\n \"o\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"o©o©o©o\"~string.split(\n \"©\"~string,\n -1~int\n )~list(string)^string_split_string_int,\n [\n \"o\"~string,\n \"o\"~string,\n \"o\"~string,\n \"o\"~string\n ]~list(string)\n)~bool^equals","type":"bool"}]},{"name":"substring","tests":[{"original":{"name":"start","expr":"'tacocat'.substring(4) == 'cat'"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 4~int\n )~string^string_substring_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"start_with_max_length","expr":"'tacocat'.substring(7) == ''"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 7~int\n )~string^string_substring_int,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"start_and_end","expr":"'tacocat'.substring(0, 4) == 'taco'"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"taco\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 0~int,\n 4~int\n )~string^string_substring_int_int,\n \"taco\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"start_and_end_equal_value","expr":"'tacocat'.substring(4, 4) == ''"},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 4~int,\n 4~int\n )~string^string_substring_int_int,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_start_and_end","expr":"'ta©o©αT'.substring(2, 6) == '©o©α'"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.substring(\n 2^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"©o©α\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.substring(\n 2~int,\n 6~int\n )~string^string_substring_int_int,\n \"©o©α\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_start_and_end_equal_value","expr":"'ta©o©αT'.substring(7, 7) == ''"},"ast":"_==_(\n \"ta©o©αT\"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"ta©o©αT\"~string.substring(\n 7~int,\n 7~int\n )~string^string_substring_int_int,\n \"\"~string\n)~bool^equals","type":"bool"}]},{"name":"trim","tests":[{"original":{"name":"blank_spaces_escaped_chars","expr":"' \\f\\n\\r\\t\\vtext '.trim() == 'text'"},"ast":"_==_(\n \" \\f\\n\\r\\t\\vtext \"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \" \\f\\n\\r\\t\\vtext \"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_space_chars_1","expr":"'\\u0085\\u00a0\\u1680text'.trim() == 'text'"},"ast":"_==_(\n \"\\u0085\\u00a0\\u1680text\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\\u0085\\u00a0\\u1680text\"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_space_chars_2","expr":"'text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009'.trim() == 'text'"},"ast":"_==_(\n \"text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009\"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_space_chars_3","expr":"'\\u200atext\\u2028\\u2029\\u202F\\u205F\\u3000'.trim() == 'text'"},"ast":"_==_(\n \"\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"text\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000\"~string.trim()~string^string_trim,\n \"text\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_no_trim","expr":"'\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'.trim() == '\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'"},"ast":"_==_(\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"~string.trim()~string^string_trim,\n \"\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff\"~string\n)~bool^equals","type":"bool"}]},{"name":"join","tests":[{"original":{"name":"empty_separator","expr":"['x', 'y'].join() == 'xy'"},"ast":"_==_(\n [\n \"x\"^#*expr.Constant_StringValue#,\n \"y\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n \"xy\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"x\"~string,\n \"y\"~string\n ]~list(string).join()~string^list_join,\n \"xy\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"dash_separator","expr":"['x', 'y'].join('-') == 'x-y'"},"ast":"_==_(\n [\n \"x\"^#*expr.Constant_StringValue#,\n \"y\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join(\n \"-\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"x-y\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n [\n \"x\"~string,\n \"y\"~string\n ]~list(string).join(\n \"-\"~string\n )~string^list_join_string,\n \"x-y\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"empty_string_empty_separator","expr":"[].join() == ''"},"ast":"_==_(\n []^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n []~list(string).join()~string^list_join,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"empty_string_dash_separator","expr":"[].join('-') == ''"},"ast":"_==_(\n []^#*expr.Expr_ListExpr#.join(\n \"-\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n []~list(string).join(\n \"-\"~string\n )~string^list_join_string,\n \"\"~string\n)~bool^equals","type":"bool"}]},{"name":"quote","tests":[{"original":{"name":"multiline","expr":"strings.quote(\"first\\nsecond\") == \"\\\"first\\\\nsecond\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"first\\nsecond\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"first\\\\nsecond\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"first\\nsecond\"~string\n )~string^strings_quote,\n \"\\\"first\\\\nsecond\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"escaped","expr":"strings.quote(\"bell\\a\") == \"\\\"bell\\\\a\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"bell\\a\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"bell\\\\a\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"bell\\a\"~string\n )~string^strings_quote,\n \"\\\"bell\\\\a\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"backspace","expr":"strings.quote(\"\\bbackspace\") == \"\\\"\\\\bbackspace\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"\\bbackspace\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"\\\\bbackspace\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"\\bbackspace\"~string\n )~string^strings_quote,\n \"\\\"\\\\bbackspace\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"form_feed","expr":"strings.quote(\"\\fform feed\") == \"\\\"\\\\fform feed\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"\\fform feed\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"\\\\fform feed\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"\\fform feed\"~string\n )~string^strings_quote,\n \"\\\"\\\\fform feed\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"carriage_return","expr":"strings.quote(\"carriage \\r return\") == \"\\\"carriage \\\\r return\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"carriage \\r return\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"carriage \\\\r return\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"carriage \\r return\"~string\n )~string^strings_quote,\n \"\\\"carriage \\\\r return\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"horizontal_tab","expr":"strings.quote(\"horizontal tab\\t\") == \"\\\"horizontal tab\\\\t\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"horizontal tab\\t\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"horizontal tab\\\\t\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"horizontal tab\\t\"~string\n )~string^strings_quote,\n \"\\\"horizontal tab\\\\t\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"vertical_tab","expr":"strings.quote(\"vertical \\v tab\") == \"\\\"vertical \\\\v tab\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"vertical \\v tab\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"vertical \\\\v tab\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"vertical \\v tab\"~string\n )~string^strings_quote,\n \"\\\"vertical \\\\v tab\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"double_slash","expr":"strings.quote(\"double \\\\\\\\ slash\") == \"\\\"double \\\\\\\\\\\\\\\\ slash\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"double \\\\\\\\ slash\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"double \\\\\\\\\\\\\\\\ slash\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"double \\\\\\\\ slash\"~string\n )~string^strings_quote,\n \"\\\"double \\\\\\\\\\\\\\\\ slash\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"two_escape_sequences","expr":"strings.quote(\"two escape sequences \\\\a\\\\n\") == \"\\\"two escape sequences \\\\\\\\a\\\\\\\\n\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"two escape sequences \\\\a\\\\n\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"two escape sequences \\\\\\\\a\\\\\\\\n\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"two escape sequences \\\\a\\\\n\"~string\n )~string^strings_quote,\n \"\\\"two escape sequences \\\\\\\\a\\\\\\\\n\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"verbatim","expr":"strings.quote(\"verbatim\") == \"\\\"verbatim\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"verbatim\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"verbatim\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"verbatim\"~string\n )~string^strings_quote,\n \"\\\"verbatim\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"ends_with","expr":"strings.quote(\"ends with \\\\\") == \"\\\"ends with \\\\\\\\\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"ends with \\\\\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"ends with \\\\\\\\\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"ends with \\\\\"~string\n )~string^strings_quote,\n \"\\\"ends with \\\\\\\\\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"starts_with","expr":"strings.quote(\"\\\\ starts with\") == \"\\\"\\\\\\\\ starts with\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"\\\\ starts with\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"\\\\\\\\ starts with\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"\\\\ starts with\"~string\n )~string^strings_quote,\n \"\\\"\\\\\\\\ starts with\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"printable_unicode","expr":"strings.quote(\"printable unicode😀\") == \"\\\"printable unicode😀\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"printable unicode😀\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"printable unicode😀\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"printable unicode😀\"~string\n )~string^strings_quote,\n \"\\\"printable unicode😀\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"mid_string_quote","expr":"strings.quote(\"mid string \\\" quote\") == \"\\\"mid string \\\\\\\" quote\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"mid string \\\" quote\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"mid string \\\\\\\" quote\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"mid string \\\" quote\"~string\n )~string^strings_quote,\n \"\\\"mid string \\\\\\\" quote\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"single_quote_with_double_quote","expr":"strings.quote('single-quote with \"double quote\"') == \"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"single-quote with \\\"double quote\\\"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"single-quote with \\\"double quote\\\"\"~string\n )~string^strings_quote,\n \"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"size_unicode_char","expr":"strings.quote(\"size('ÿ')\") == \"\\\"size('ÿ')\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"size('ÿ')\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"size('ÿ')\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"size('ÿ')\"~string\n )~string^strings_quote,\n \"\\\"size('ÿ')\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"size_unicode_string","expr":"strings.quote(\"size('πέντε')\") == \"\\\"size('πέντε')\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"size('πέντε')\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"size('πέντε')\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"size('πέντε')\"~string\n )~string^strings_quote,\n \"\\\"size('πέντε')\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode","expr":"strings.quote(\"завтра\") == \"\\\"завтра\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"завтра\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"завтра\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"завтра\"~string\n )~string^strings_quote,\n \"\\\"завтра\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"unicode_code_points","expr":"strings.quote(\"\\U0001F431\\U0001F600\\U0001F61B\")","value":{"stringValue":"\"🐱😀😛\""}},"ast":"strings^#*expr.Expr_IdentExpr#.quote(\n \"🐱😀😛\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"strings.quote(\n \"🐱😀😛\"~string\n)~string^strings_quote","type":"string"},{"original":{"name":"unicode_2","expr":"strings.quote(\"ta©o©αT\") == \"\\\"ta©o©αT\\\"\""},"ast":"_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n \"ta©o©αT\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"\\\"ta©o©αT\\\"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n strings.quote(\n \"ta©o©αT\"~string\n )~string^strings_quote,\n \"\\\"ta©o©αT\\\"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"empty_quote","expr":"strings.quote(\"\")","value":{"stringValue":"\"\""}},"ast":"strings^#*expr.Expr_IdentExpr#.quote(\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"strings.quote(\n \"\"~string\n)~string^strings_quote","type":"string"}]},{"name":"format","tests":[{"original":{"name":"no-op","expr":"\"no substitution\".format([])","value":{"stringValue":"no substitution"}},"ast":"\"no substitution\"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"no substitution\"~string.format(\n []~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"mid-string substitution","expr":"\"str is %s and some more\".format([\"filler\"])","value":{"stringValue":"str is filler and some more"}},"ast":"\"str is %s and some more\"^#*expr.Constant_StringValue#.format(\n [\n \"filler\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"str is %s and some more\"~string.format(\n [\n \"filler\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"percent escaping","expr":"\"%% and also %%\".format([])","value":{"stringValue":"% and also %"}},"ast":"\"%% and also %%\"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%% and also %%\"~string.format(\n []~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"substitution inside escaped percent signs","expr":"\"%%%s%%\".format([\"text\"])","value":{"stringValue":"%text%"}},"ast":"\"%%%s%%\"^#*expr.Constant_StringValue#.format(\n [\n \"text\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%%%s%%\"~string.format(\n [\n \"text\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"substitution with one escaped percent sign on the right","expr":"\"%s%%\".format([\"percent on the right\"])","value":{"stringValue":"percent on the right%"}},"ast":"\"%s%%\"^#*expr.Constant_StringValue#.format(\n [\n \"percent on the right\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s%%\"~string.format(\n [\n \"percent on the right\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"substitution with one escaped percent sign on the left","expr":"\"%%%s\".format([\"percent on the left\"])","value":{"stringValue":"%percent on the left"}},"ast":"\"%%%s\"^#*expr.Constant_StringValue#.format(\n [\n \"percent on the left\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%%%s\"~string.format(\n [\n \"percent on the left\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"multiple substitutions","expr":"\"%d %d %d, %s %s %s, %d %d %d, %s %s %s\".format([1, 2, 3, \"A\", \"B\", \"C\", 4, 5, 6, \"D\", \"E\", \"F\"])","value":{"stringValue":"1 2 3, A B C, 4 5 6, D E F"}},"ast":"\"%d %d %d, %s %s %s, %d %d %d, %s %s %s\"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n \"A\"^#*expr.Constant_StringValue#,\n \"B\"^#*expr.Constant_StringValue#,\n \"C\"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n \"D\"^#*expr.Constant_StringValue#,\n \"E\"^#*expr.Constant_StringValue#,\n \"F\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d %d %d, %s %s %s, %d %d %d, %s %s %s\"~string.format(\n [\n 1~int,\n 2~int,\n 3~int,\n \"A\"~string,\n \"B\"~string,\n \"C\"~string,\n 4~int,\n 5~int,\n 6~int,\n \"D\"~string,\n \"E\"~string,\n \"F\"~string\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"percent sign escape sequence support","expr":"\"%%escaped %s%%\".format([\"percent\"])","value":{"stringValue":"%escaped percent%"}},"ast":"\"%%escaped %s%%\"^#*expr.Constant_StringValue#.format(\n [\n \"percent\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%%escaped %s%%\"~string.format(\n [\n \"percent\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"fixed point formatting clause","expr":"\"%.3f\".format([1.2345])","value":{"stringValue":"1.234"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"binary formatting clause","expr":"\"this is 5 in binary: %b\".format([5])","value":{"stringValue":"this is 5 in binary: 101"}},"ast":"\"this is 5 in binary: %b\"^#*expr.Constant_StringValue#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"this is 5 in binary: %b\"~string.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"uint support for binary formatting","expr":"\"unsigned 64 in binary: %b\".format([uint(64)])","value":{"stringValue":"unsigned 64 in binary: 1000000"}},"ast":"\"unsigned 64 in binary: %b\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"unsigned 64 in binary: %b\"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"bool support for binary formatting","expr":"\"bit set from bool: %b\".format([true])","value":{"stringValue":"bit set from bool: 1"}},"ast":"\"bit set from bool: %b\"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"bit set from bool: %b\"~string.format(\n [\n true~bool\n ]~list(bool)\n)~string^string_format","type":"string"},{"original":{"name":"octal formatting clause","expr":"\"%o\".format([11])","value":{"stringValue":"13"}},"ast":"\"%o\"^#*expr.Constant_StringValue#.format(\n [\n 11^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%o\"~string.format(\n [\n 11~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"uint support for octal formatting clause","expr":"\"this is an unsigned octal: %o\".format([uint(65535)])","value":{"stringValue":"this is an unsigned octal: 177777"}},"ast":"\"this is an unsigned octal: %o\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 65535^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"this is an unsigned octal: %o\"~string.format(\n [\n uint(\n 65535~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"lowercase hexadecimal formatting clause","expr":"\"%x is 20 in hexadecimal\".format([30])","value":{"stringValue":"1e is 20 in hexadecimal"}},"ast":"\"%x is 20 in hexadecimal\"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x is 20 in hexadecimal\"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"uppercase hexadecimal formatting clause","expr":"\"%X is 20 in hexadecimal\".format([30])","value":{"stringValue":"1E is 20 in hexadecimal"}},"ast":"\"%X is 20 in hexadecimal\"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X is 20 in hexadecimal\"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"unsigned support for hexadecimal formatting clause","expr":"\"%X is 6000 in hexadecimal\".format([uint(6000)])","value":{"stringValue":"1770 is 6000 in hexadecimal"}},"ast":"\"%X is 6000 in hexadecimal\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 6000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X is 6000 in hexadecimal\"~string.format(\n [\n uint(\n 6000~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"string support with hexadecimal formatting clause","expr":"\"%x\".format([\"Hello world!\"])","value":{"stringValue":"48656c6c6f20776f726c6421"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n \"Hello world!\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n \"Hello world!\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"string support with uppercase hexadecimal formatting clause","expr":"\"%X\".format([\"Hello world!\"])","value":{"stringValue":"48656C6C6F20776F726C6421"}},"ast":"\"%X\"^#*expr.Constant_StringValue#.format(\n [\n \"Hello world!\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X\"~string.format(\n [\n \"Hello world!\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"byte support with hexadecimal formatting clause","expr":"\"%x\".format([b\"byte string\"])","value":{"stringValue":"6279746520737472696e67"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n b\"byte string\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n b\"byte string\"~bytes\n ]~list(bytes)\n)~string^string_format","type":"string"},{"original":{"name":"byte support with uppercase hexadecimal formatting clause","expr":"\"%X\".format([b\"byte string\"])","value":{"stringValue":"6279746520737472696E67"}},"ast":"\"%X\"^#*expr.Constant_StringValue#.format(\n [\n b\"byte string\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X\"~string.format(\n [\n b\"byte string\"~bytes\n ]~list(bytes)\n)~string^string_format","type":"string"},{"original":{"name":"scientific notation formatting clause","expr":"\"%.6e\".format([1052.032911275])","value":{"stringValue":"1.052033e+03"}},"ast":"\"%.6e\"^#*expr.Constant_StringValue#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.6e\"~string.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"default precision for fixed-point clause","expr":"\"%f\".format([2.71828])","value":{"stringValue":"2.718280"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"default precision for scientific notation","expr":"\"%e\".format([2.71828])","value":{"stringValue":"2.718280e+00"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"NaN support for scientific notation","expr":"\"%e\".format([double(\"NaN\")])","value":{"stringValue":"NaN"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n double(\n \"NaN\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"positive infinity support for scientific notation","expr":"\"%e\".format([double(\"Infinity\")])","value":{"stringValue":"Infinity"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n double(\n \"Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"negative infinity support for scientific notation","expr":"\"%e\".format([double(\"-Infinity\")])","value":{"stringValue":"-Infinity"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"NaN support for decimal","expr":"\"%d\".format([double(\"NaN\")])","value":{"stringValue":"NaN"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n double(\n \"NaN\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"positive infinity support for decimal","expr":"\"%d\".format([double(\"Infinity\")])","value":{"stringValue":"Infinity"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n double(\n \"Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"negative infinity support for decimal","expr":"\"%d\".format([double(\"-Infinity\")])","value":{"stringValue":"-Infinity"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"NaN support for fixed-point","expr":"\"%f\".format([double(\"NaN\")])","value":{"stringValue":"NaN"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n double(\n \"NaN\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"positive infinity support for fixed-point","expr":"\"%f\".format([double(\"Infinity\")])","value":{"stringValue":"Infinity"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n double(\n \"Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"negative infinity support for fixed-point","expr":"\"%f\".format([double(\"-Infinity\")])","value":{"stringValue":"-Infinity"}},"ast":"\"%f\"^#*expr.Constant_StringValue#.format(\n [\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%f\"~string.format(\n [\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"uint support for decimal clause","expr":"\"%d\".format([uint(64)])","value":{"stringValue":"64"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format","type":"string"},{"original":{"name":"null support for string","expr":"\"%s\".format([null])","value":{"stringValue":"null"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n null~null\n ]~list(null)\n)~string^string_format","type":"string"},{"original":{"name":"int support for string","expr":"\"%s\".format([999999999999])","value":{"stringValue":"999999999999"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n 999999999999^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n 999999999999~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"bytes support for string","expr":"\"%s\".format([b\"xyz\"])","value":{"stringValue":"xyz"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n b\"xyz\"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n b\"xyz\"~bytes\n ]~list(bytes)\n)~string^string_format","type":"string"},{"original":{"name":"type() support for string","expr":"\"%s\".format([type(\"test string\")])","value":{"stringValue":"string"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n type(\n \"test string\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n type(\n \"test string\"~string\n )~type(string)^type\n ]~list(type(string))\n)~string^string_format","type":"string"},{"original":{"name":"timestamp support for string","expr":"\"%s\".format([timestamp(\"2023-02-03T23:31:20+00:00\")])","value":{"stringValue":"2023-02-03T23:31:20Z"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n timestamp(\n \"2023-02-03T23:31:20+00:00\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n timestamp(\n \"2023-02-03T23:31:20+00:00\"~string\n )~timestamp^string_to_timestamp\n ]~list(timestamp)\n)~string^string_format","type":"string"},{"original":{"name":"duration support for string","expr":"\"%s\".format([duration(\"1h45m47s\")])","value":{"stringValue":"6347s"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n duration(\n \"1h45m47s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n duration(\n \"1h45m47s\"~string\n )~duration^string_to_duration\n ]~list(duration)\n)~string^string_format","type":"string"},{"original":{"name":"list support for string","expr":"\"%s\".format([[\"abc\", 3.14, null, [9, 8, 7, 6], timestamp(\"2023-02-03T23:31:20Z\")]])","value":{"stringValue":"[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n [\n \"abc\"^#*expr.Constant_StringValue#,\n 3.14^#*expr.Constant_DoubleValue#,\n null^#*expr.Constant_NullValue#,\n [\n 9^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n timestamp(\n \"2023-02-03T23:31:20Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n [\n \"abc\"~string,\n 3.14~double,\n null~null,\n [\n 9~int,\n 8~int,\n 7~int,\n 6~int\n ]~list(int),\n timestamp(\n \"2023-02-03T23:31:20Z\"~string\n )~timestamp^string_to_timestamp\n ]~list(dyn)\n ]~list(list(dyn))\n)~string^string_format","type":"string"},{"original":{"name":"map support for string","expr":"\"%s\".format([{\"key1\": b\"xyz\", \"key5\": null, \"key2\": duration(\"2h\"), \"key4\": true, \"key3\": 2.71828}])","value":{"stringValue":"{key1: xyz, key2: 7200s, key3: 2.71828, key4: true, key5: null}"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n \"key1\"^#*expr.Constant_StringValue#:b\"xyz\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key5\"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key2\"^#*expr.Constant_StringValue#:duration(\n \"2h\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n \"key4\"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n \"key3\"^#*expr.Constant_StringValue#:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n {\n \"key1\"~string:b\"xyz\"~bytes,\n \"key5\"~string:null~null,\n \"key2\"~string:duration(\n \"2h\"~string\n )~duration^string_to_duration,\n \"key4\"~string:true~bool,\n \"key3\"~string:2.71828~double\n }~map(string, dyn)\n ]~list(map(string, dyn))\n)~string^string_format","type":"string"},{"original":{"name":"map support (all key types)","expr":"\"%s\".format([{1: \"value1\", uint(2): \"value2\", true: double(\"NaN\")}])","value":{"stringValue":"{1: value1, 2: value2, true: NaN}"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:\"value1\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n uint(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#:\"value2\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n {\n 1~int:\"value1\"~string,\n uint(\n 2~int\n )~uint^int64_to_uint64:\"value2\"~string,\n true~bool:double(\n \"NaN\"~string\n )~double^string_to_double\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format","type":"string"},{"original":{"name":"boolean support for %s","expr":"\"%s, %s\".format([true, false])","value":{"stringValue":"true, false"}},"ast":"\"%s, %s\"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s, %s\"~string.format(\n [\n true~bool,\n false~bool\n ]~list(bool)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for string formatting clause","expr":"\"%s\".format([dyn(\"a string\")])","value":{"stringValue":"a string"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n \"a string\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n \"a string\"~string\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for numbers with string formatting clause","expr":"\"%s, %s\".format([dyn(32), dyn(56.8)])","value":{"stringValue":"32, 56.8"}},"ast":"\"%s, %s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 32^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 56.8^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s, %s\"~string.format(\n [\n dyn(\n 32~int\n )~dyn^to_dyn,\n dyn(\n 56.8~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for integer formatting clause","expr":"\"%d\".format([dyn(128)])","value":{"stringValue":"128"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 128^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n dyn(\n 128~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for integer formatting clause (unsigned)","expr":"\"%d\".format([dyn(256u)])","value":{"stringValue":"256"}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 256u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%d\"~string.format(\n [\n dyn(\n 256u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for hex formatting clause","expr":"\"%x\".format([dyn(22)])","value":{"stringValue":"16"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n dyn(\n 22~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for hex formatting clause (uppercase)","expr":"\"%X\".format([dyn(26)])","value":{"stringValue":"1A"}},"ast":"\"%X\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 26^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%X\"~string.format(\n [\n dyn(\n 26~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for unsigned hex formatting clause","expr":"\"%x\".format([dyn(500u)])","value":{"stringValue":"1f4"}},"ast":"\"%x\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 500u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%x\"~string.format(\n [\n dyn(\n 500u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for fixed-point formatting clause","expr":"\"%.3f\".format([dyn(4.5)])","value":{"stringValue":"4.500"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 4.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n dyn(\n 4.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for scientific notation","expr":"\"%e\".format([dyn(2.71828)])","value":{"stringValue":"2.718280e+00"}},"ast":"\"%e\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 2.71828^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%e\"~string.format(\n [\n dyn(\n 2.71828~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype NaN/infinity support","expr":"\"%s\".format([[double(\"NaN\"), double(\"Infinity\"), double(\"-Infinity\")]])","value":{"stringValue":"[NaN, Infinity, -Infinity]"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n [\n double(\n \"NaN\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n \"Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n \"-Infinity\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n [\n double(\n \"NaN\"~string\n )~double^string_to_double,\n double(\n \"Infinity\"~string\n )~double^string_to_double,\n double(\n \"-Infinity\"~string\n )~double^string_to_double\n ]~list(double)\n ]~list(list(double))\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for timestamp","expr":"\"%s\".format([dyn(timestamp(\"2009-11-10T23:00:00Z\"))])","value":{"stringValue":"2009-11-10T23:00:00Z"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n timestamp(\n \"2009-11-10T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n timestamp(\n \"2009-11-10T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for duration","expr":"\"%s\".format([dyn(duration(\"8747s\"))])","value":{"stringValue":"8747s"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n duration(\n \"8747s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n duration(\n \"8747s\"~string\n )~duration^string_to_duration\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for lists","expr":"\"%s\".format([dyn([6, 4.2, \"a string\"])])","value":{"stringValue":"[6, 4.2, a string]"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n [\n 6^#*expr.Constant_Int64Value#,\n 4.2^#*expr.Constant_DoubleValue#,\n \"a string\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n dyn(\n [\n 6~int,\n 4.2~double,\n \"a string\"~string\n ]~list(dyn)\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"dyntype support for maps","expr":"\"%s\".format([{\"strKey\":\"x\", 6:duration(\"422s\"), true:42}])","value":{"stringValue":"{6: 422s, strKey: x, true: 42}"}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n \"strKey\"^#*expr.Constant_StringValue#:\"x\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:duration(\n \"422s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%s\"~string.format(\n [\n {\n \"strKey\"~string:\"x\"~string,\n 6~int:duration(\n \"422s\"~string\n )~duration^string_to_duration,\n true~bool:42~int\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format","type":"string"},{"original":{"name":"string substitution in a string variable","expr":"str_var.format([\"filler\"])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%s"}}},"value":{"stringValue":"filler"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n \"filler\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n \"filler\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"multiple substitutions in a string variable","expr":"str_var.format([1, 2, 3, \"A\", \"B\", \"C\", 4, 5, 6, \"D\", \"E\", \"F\"])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%d %d %d, %s %s %s, %d %d %d, %s %s %s"}}},"value":{"stringValue":"1 2 3, A B C, 4 5 6, D E F"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n \"A\"^#*expr.Constant_StringValue#,\n \"B\"^#*expr.Constant_StringValue#,\n \"C\"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n \"D\"^#*expr.Constant_StringValue#,\n \"E\"^#*expr.Constant_StringValue#,\n \"F\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 1~int,\n 2~int,\n 3~int,\n \"A\"~string,\n \"B\"~string,\n \"C\"~string,\n 4~int,\n 5~int,\n 6~int,\n \"D\"~string,\n \"E\"~string,\n \"F\"~string\n ]~list(dyn)\n)~string^string_format","type":"string"},{"original":{"name":"substitution inside escaped percent signs in a string variable","expr":"str_var.format([\"text\"])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%%%s%%"}}},"value":{"stringValue":"%text%"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n \"text\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n \"text\"~string\n ]~list(string)\n)~string^string_format","type":"string"},{"original":{"name":"fixed point formatting clause in a string variable","expr":"str_var.format([1.2345])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%.3f"}}},"value":{"stringValue":"1.234"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"binary formatting clause in a string variable","expr":"str_var.format([5])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%b"}}},"value":{"stringValue":"101"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format","type":"string"},{"original":{"name":"scientific notation formatting clause in a string variable","expr":"str_var.format([1052.032911275])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%.6e"}}},"value":{"stringValue":"1.052033e+03"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"default precision for fixed-point clause in a string variable","expr":"str_var.format([2.71828])","typeEnv":[{"name":"str_var","ident":{"type":{"primitive":"STRING"}}}],"bindings":{"str_var":{"value":{"stringValue":"%f"}}},"value":{"stringValue":"2.718280"}},"ast":"str_var^#*expr.Expr_IdentExpr#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"str_var~string^str_var.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_insignificant_zeroes_removed","expr":"\"%.0f\".format([123.000000])","value":{"stringValue":"123"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 123^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 123~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_positive_round_to_whole_number","expr":"\"%.0f\".format([3.5001])","value":{"stringValue":"4"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 3.5001^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 3.5001~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_negative_truncate_to_whole_number","expr":"\"%.0f\".format([3.4999])","value":{"stringValue":"3"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 3.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 3.4999~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_halfway_round_up_to_nearest_even","expr":"\"%.0f\".format([1.5])","value":{"stringValue":"2"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 1.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 1.5~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_halfway_truncate_to_nearest_even","expr":"\"%.0f\".format([2.5])","value":{"stringValue":"2"}},"ast":"\"%.0f\"^#*expr.Constant_StringValue#.format(\n [\n 2.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.0f\"~string.format(\n [\n 2.5~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_positive_round_up","expr":"\"%.3f\".format([123.4999])","value":{"stringValue":"123.500"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n 123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n 123.4999~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_positive_round_down","expr":"\"%.3f\".format([123.4994])","value":{"stringValue":"123.499"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n 123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n 123.4994~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_negative_round_up","expr":"\"%.3f\".format([-123.4999])","value":{"stringValue":"-123.500"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n -123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n -123.4999~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_negative_round_down","expr":"\"%.3f\".format([-123.4994])","value":{"stringValue":"-123.499"}},"ast":"\"%.3f\"^#*expr.Constant_StringValue#.format(\n [\n -123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.3f\"~string.format(\n [\n -123.4994~double\n ]~list(double)\n)~string^string_format","type":"string"},{"original":{"name":"format_%f_zero_padding","expr":"\"%.5f\".format([-1.2])","value":{"stringValue":"-1.20000"}},"ast":"\"%.5f\"^#*expr.Constant_StringValue#.format(\n [\n -1.2^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"\"%.5f\"~string.format(\n [\n -1.2~double\n ]~list(double)\n)~string^string_format","type":"string"}]},{"name":"format_errors","tests":[{"original":{"name":"unrecognized formatting clause","expr":"\"%a\".format([1])","disableCheck":true,"evalError":{"errors":[{"message":"could not parse formatting clause: unrecognized formatting clause \"a\""}]}},"ast":"\"%a\"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:12: could not parse formatting clause: unrecognized formatting clause \"a\"\n | \"%a\".format([1])\n | ...........^"},{"original":{"name":"out of bounds arg index","expr":"\"%d %d %d\".format([0, 1])","disableCheck":true,"evalError":{"errors":[{"message":"index 2 out of range"}]}},"ast":"\"%d %d %d\"^#*expr.Constant_StringValue#.format(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: index 2 out of range\n | \"%d %d %d\".format([0, 1])\n | .................^"},{"original":{"name":"string substitution is not allowed with binary clause","expr":"\"string is %b\".format([\"abc\"])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers and bools can be formatted as binary, was given string"}]}},"ast":"\"string is %b\"^#*expr.Constant_StringValue#.format(\n [\n \"abc\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, and bools can be formatted as binary, was given string\n | \"string is %b\".format([\"abc\"])\n | .......................^"},{"original":{"name":"duration substitution not allowed with decimal clause","expr":"\"%d\".format([duration(\"30m2s\")])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: decimal clause can only be used on integers, was given google.protobuf.Duration"}]}},"ast":"\"%d\"^#*expr.Constant_StringValue#.format(\n [\n duration(\n \"30m2s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:22: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given google.protobuf.Duration\n | \"%d\".format([duration(\"30m2s\")])\n | .....................^"},{"original":{"name":"string substitution not allowed with octal clause","expr":"\"octal: %o\".format([\"a string\"])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: octal clause can only be used on integers, was given string"}]}},"ast":"\"octal: %o\"^#*expr.Constant_StringValue#.format(\n [\n \"a string\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:21: error during formatting: octal clause can only be used on ints and uints, was given string\n | \"octal: %o\".format([\"a string\"])\n | ....................^"},{"original":{"name":"double substitution not allowed with hex clause","expr":"\"double is %x\".format([0.5])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given double"}]}},"ast":"\"double is %x\"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given double\n | \"double is %x\".format([0.5])\n | .......................^"},{"original":{"name":"uppercase not allowed for scientific clause","expr":"\"double is %E\".format([0.5])","disableCheck":true,"evalError":{"errors":[{"message":"could not parse formatting clause: unrecognized formatting clause \"E\""}]}},"ast":"\"double is %E\"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:22: could not parse formatting clause: unrecognized formatting clause \"E\"\n | \"double is %E\".format([0.5])\n | .....................^"},{"original":{"name":"object not allowed","expr":"\"object is %s\".format([cel.expr.conformance.proto3.TestAllTypes{}])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes"}]}},"ast":"\"object is %s\"^#*expr.Constant_StringValue#.format(\n [\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:64: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | \"object is %s\".format([cel.expr.conformance.proto3.TestAllTypes{}])\n | ...............................................................^"},{"original":{"name":"object inside list","expr":"\"%s\".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes"}]}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:61: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | \"%s\".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])\n | ............................................................^"},{"original":{"name":"object inside map","expr":"\"%s\".format([{1: \"a\", 2: cel.expr.conformance.proto3.TestAllTypes{}}])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes"}]}},"ast":"\"%s\"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:\"a\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:66: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | \"%s\".format([{1: \"a\", 2: cel.expr.conformance.proto3.TestAllTypes{}}])\n | .................................................................^"},{"original":{"name":"null not allowed for %d","expr":"\"null: %d\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: decimal clause can only be used on integers, was given null_type"}]}},"ast":"\"null: %d\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given null_type\n | \"null: %d\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %e","expr":"\"null: %e\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: scientific clause can only be used on doubles, was given null_type"}]}},"ast":"\"null: %e\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: scientific clause can only be used on ints, uints, and doubles, was given null_type\n | \"null: %e\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %f","expr":"\"null: %f\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: fixed-point clause can only be used on doubles, was given null_type"}]}},"ast":"\"null: %f\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: fixed-point clause can only be used on ints, uints, and doubles, was given null_type\n | \"null: %f\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %x","expr":"\"null: %x\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type"}]}},"ast":"\"null: %x\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | \"null: %x\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %X","expr":"\"null: %X\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type"}]}},"ast":"\"null: %X\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | \"null: %X\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %b","expr":"\"null: %b\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: only integers and bools can be formatted as binary, was given null_type"}]}},"ast":"\"null: %b\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, and bools can be formatted as binary, was given null_type\n | \"null: %b\".format([null])\n | ...................^"},{"original":{"name":"null not allowed for %o","expr":"\"null: %o\".format([null])","disableCheck":true,"evalError":{"errors":[{"message":"error during formatting: octal clause can only be used on integers, was given null_type"}]}},"ast":"\"null: %o\"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: error during formatting: octal clause can only be used on ints and uints, was given null_type\n | \"null: %o\".format([null])\n | ...................^"}]},{"name":"value_errors","tests":[{"original":{"name":"charat_out_of_range","expr":"'tacocat'.charAt(30) == ''","evalError":{"errors":[{"message":"index out of range: 30"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.charAt(\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.charAt(\n 30~int\n )~string^string_char_at_int,\n \"\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"indexof_out_of_range","expr":"'tacocat'.indexOf('a', 30) == -1","evalError":{"errors":[{"message":"index out of range: 30"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.indexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.indexOf(\n \"a\"~string,\n 30~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"lastindexof_negative_index","expr":"'tacocat'.lastIndexOf('a', -1) == -1","evalError":{"errors":[{"message":"index out of range: -1"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"a\"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"a\"~string,\n -1~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"lastindexof_out_of_range","expr":"'tacocat'.lastIndexOf('a', 30) == -1","evalError":{"errors":[{"message":"index out of range: 30"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.lastIndexOf(\n \"a\"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.lastIndexOf(\n \"a\"~string,\n 30~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals","type":"bool"},{"original":{"name":"substring_out_of_range","expr":"'tacocat'.substring(40) == 'cat'","evalError":{"errors":[{"message":"index out of range: 40"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 40^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 40~int\n )~string^string_substring_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_negative_index","expr":"'tacocat'.substring(-1) == 'cat'","evalError":{"errors":[{"message":"index out of range: -1"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n -1~int\n )~string^string_substring_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_end_index_out_of_range","expr":"'tacocat'.substring(1, 50) == 'cat'","evalError":{"errors":[{"message":"index out of range: 50"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 1~int,\n 50~int\n )~string^string_substring_int_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_begin_index_out_of_range","expr":"'tacocat'.substring(49, 50) == 'cat'","evalError":{"errors":[{"message":"index out of range: 49"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 49^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"cat\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 49~int,\n 50~int\n )~string^string_substring_int_int,\n \"cat\"~string\n)~bool^equals","type":"bool"},{"original":{"name":"substring_end_index_greater_than_begin_index","expr":"'tacocat'.substring(4, 3) == ''","evalError":{"errors":[{"message":"invalid substring range. start: 4, end: 3"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n \"tacocat\"~string.substring(\n 4~int,\n 3~int\n )~string^string_substring_int_int,\n \"\"~string\n)~bool^equals","type":"bool"}]},{"name":"type_errors","tests":[{"original":{"name":"charat_invalid_type","expr":"42.charAt(2) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:10: found no matching overload for 'charAt' applied to 'int.(int)'\n | 42.charAt(2) == ''\n | .........^"},{"original":{"name":"charat_invalid_argument","expr":"'hello'.charAt(true) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"hello\"^#*expr.Constant_StringValue#.charAt(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:15: found no matching overload for 'charAt' applied to 'string.(bool)'\n | 'hello'.charAt(true) == ''\n | ..............^"},{"original":{"name":"indexof_unary_invalid_type","expr":"24.indexOf('2') == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 24^#*expr.Constant_Int64Value#.indexOf(\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string)'\n | 24.indexOf('2') == 0\n | ..........^"},{"original":{"name":"indexof_unary_invalid_argument","expr":"'hello'.indexOf(true) == 1","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"hello\"^#*expr.Constant_StringValue#.indexOf(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:16: found no matching overload for 'indexOf' applied to 'string.(bool)'\n | 'hello'.indexOf(true) == 1\n | ...............^"},{"original":{"name":"indexof_binary_invalid_argument","expr":"42.indexOf('4', 0) == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.indexOf(\n \"4\"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string, int)'\n | 42.indexOf('4', 0) == 0\n | ..........^"},{"original":{"name":"indexof_binary_invalid_argument_2","expr":"'42'.indexOf(4, 0) == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.indexOf(\n 4^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(int, int)'\n | '42'.indexOf(4, 0) == 0\n | ............^"},{"original":{"name":"indexof_binary_both_invalid_arguments","expr":"'42'.indexOf('4', '0') == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.indexOf(\n \"4\"^#*expr.Constant_StringValue#,\n \"0\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, string)'\n | '42'.indexOf('4', '0') == 0\n | ............^"},{"original":{"name":"indexof_ternary_invalid_arguments","expr":"'42'.indexOf('4', 0, 1) == 0","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.indexOf(\n \"4\"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, int, int)'\n | '42'.indexOf('4', 0, 1) == 0\n | ............^"},{"original":{"name":"split_invalid_type","expr":"42.split('2') == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.split(\n \"2\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('2') == ['4']\n | ........^"},{"original":{"name":"replace_invalid_type","expr":"42.replace(2, 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(int, int)'\n | 42.replace(2, 1) == '41'\n | ..........^"},{"original":{"name":"replace_binary_invalid_argument","expr":"'42'.replace(2, 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, int)'\n | '42'.replace(2, 1) == '41'\n | ............^"},{"original":{"name":"replace_binary_invalid_argument_2","expr":"'42'.replace('2', 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int)'\n | '42'.replace('2', 1) == '41'\n | ............^"},{"original":{"name":"replace_ternary_invalid_argument","expr":"42.replace('2', '1', 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(string, string, int)'\n | 42.replace('2', '1', 1) == '41'\n | ..........^"},{"original":{"name":"replace_ternary_invalid_argument_2","expr":"'42'.replace(2, '1', 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n \"1\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, string, int)'\n | '42'.replace(2, '1', 1) == '41'\n | ............^"},{"original":{"name":"replace_ternary_invalid_argument_3","expr":"'42'.replace('2', 1, 1) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int, int)'\n | '42'.replace('2', 1, 1) == '41'\n | ............^"},{"original":{"name":"replace_ternary_invalid_argument_4","expr":"'42'.replace('2', '1', '1') == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, string)'\n | '42'.replace('2', '1', '1') == '41'\n | ............^"},{"original":{"name":"replace_quaternary_invalid_argument","expr":"'42'.replace('2', '1', 1, false) == '41'","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.replace(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n \"41\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, int, bool)'\n | '42'.replace('2', '1', 1, false) == '41'\n | ............^"},{"original":{"name":"split_invalid_type_empty_arg","expr":"42.split('') == ['4', '2']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.split(\n \"\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#,\n \"2\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('') == ['4', '2']\n | ........^"},{"original":{"name":"split_invalid_argument","expr":"'42'.split(2) == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int)'\n | '42'.split(2) == ['4']\n | ..........^"},{"original":{"name":"split_binary_invalid_type","expr":"42.split('2', '1') == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 42^#*expr.Constant_Int64Value#.split(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string, string)'\n | 42.split('2', '1') == ['4']\n | ........^"},{"original":{"name":"split_binary_invalid_argument","expr":"'42'.split(2, 1) == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int, int)'\n | '42'.split(2, 1) == ['4']\n | ..........^"},{"original":{"name":"split_binary_invalid_argument_2","expr":"'42'.split('2', '1') == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n \"2\"^#*expr.Constant_StringValue#,\n \"1\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, string)'\n | '42'.split('2', '1') == ['4']\n | ..........^"},{"original":{"name":"split_ternary_invalid_argument","expr":"'42'.split('2', 1, 1) == ['4']","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"42\"^#*expr.Constant_StringValue#.split(\n \"2\"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n \"4\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, int, int)'\n | '42'.split('2', 1, 1) == ['4']\n | ..........^"},{"original":{"name":"substring_ternary_invalid_argument","expr":"'hello'.substring(1, 2, 3) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"hello\"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:18: found no matching overload for 'substring' applied to 'string.(int, int, int)'\n | 'hello'.substring(1, 2, 3) == ''\n | .................^"},{"original":{"name":"substring_binary_invalid_type","expr":"30.substring(true, 3) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n 30^#*expr.Constant_Int64Value#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:13: found no matching overload for 'substring' applied to 'int.(bool, int)'\n | 30.substring(true, 3) == ''\n | ............^"},{"original":{"name":"substring_binary_invalid_argument","expr":"'tacocat'.substring(true, 3) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(bool, int)'\n | 'tacocat'.substring(true, 3) == ''\n | ...................^"},{"original":{"name":"substring_binary_invalid_argument_2","expr":"'tacocat'.substring(0, false) == ''","disableCheck":true,"evalError":{"errors":[{"message":"no such overload"}]}},"ast":"_==_(\n \"tacocat\"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n \"\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","error":"ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(int, bool)'\n | 'tacocat'.substring(0, false) == ''\n | ...................^"}]}]},{"name":"timestamps","suites":[{"name":"timestamp_conversions","tests":[{"original":{"name":"toInt_timestamp","expr":"int(timestamp('2009-02-13T23:31:30Z'))","value":{"int64Value":"1234567890"}},"ast":"int(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"int(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64","type":"int"},{"original":{"name":"toString_timestamp","expr":"string(timestamp('2009-02-13T23:31:30Z'))","value":{"stringValue":"2009-02-13T23:31:30Z"}},"ast":"string(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string","type":"string"},{"original":{"name":"toString_timestamp_nanos","expr":"string(timestamp('9999-12-31T23:59:59.999999999Z'))","value":{"stringValue":"9999-12-31T23:59:59.999999999Z"}},"ast":"string(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string","type":"string"},{"original":{"name":"toType_timestamp","expr":"type(timestamp('2009-02-13T23:31:30Z'))","value":{"typeValue":"google.protobuf.Timestamp"}},"ast":"type(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~type(timestamp)^type","type":"type(timestamp)"},{"original":{"name":"type_comparison","expr":"google.protobuf.Timestamp == type(timestamp('2009-02-13T23:31:30Z'))","value":{"boolValue":true}},"ast":"_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Timestamp^#*expr.Expr_SelectExpr#,\n type(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Timestamp~type(timestamp)^google.protobuf.Timestamp,\n type(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n )~type(timestamp)^type\n)~bool^equals","type":"bool"}]},{"name":"duration_conversions","tests":[{"original":{"name":"toString_duration","expr":"string(duration('1000000s'))","value":{"stringValue":"1000000s"}},"ast":"string(\n duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"string(\n duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n)~string^duration_to_string","type":"string"},{"original":{"name":"toType_duration","expr":"type(duration('1000000s'))","value":{"typeValue":"google.protobuf.Duration"}},"ast":"type(\n duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"type(\n duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n)~type(duration)^type","type":"type(duration)"},{"original":{"name":"type_comparison","expr":"google.protobuf.Duration == type(duration('1000000s'))","value":{"boolValue":true}},"ast":"_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Duration^#*expr.Expr_SelectExpr#,\n type(\n duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n google.protobuf.Duration~type(duration)^google.protobuf.Duration,\n type(\n duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n )~type(duration)^type\n)~bool^equals","type":"bool"}]},{"name":"timestamp_selectors","tests":[{"original":{"name":"getDate","expr":"timestamp('2009-02-13T23:31:30Z').getDate()","value":{"int64Value":"13"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDate()~int^timestamp_to_day_of_month_1_based","type":"int"},{"original":{"name":"getDayOfMonth","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfMonth()","value":{"int64Value":"12"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth()~int^timestamp_to_day_of_month","type":"int"},{"original":{"name":"getDayOfWeek","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfWeek()","value":{"int64Value":"5"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfWeek()~int^timestamp_to_day_of_week","type":"int"},{"original":{"name":"getDayOfYear","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfYear()","value":{"int64Value":"43"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfYear()~int^timestamp_to_day_of_year","type":"int"},{"original":{"name":"getFullYear","expr":"timestamp('2009-02-13T23:31:30Z').getFullYear()","value":{"int64Value":"2009"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getFullYear()~int^timestamp_to_year","type":"int"},{"original":{"name":"getHours","expr":"timestamp('2009-02-13T23:31:30Z').getHours()","value":{"int64Value":"23"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getHours()~int^timestamp_to_hours","type":"int"},{"original":{"name":"getMilliseconds","expr":"timestamp('2009-02-13T23:31:20.123456789Z').getMilliseconds()","value":{"int64Value":"123"}},"ast":"timestamp(\n \"2009-02-13T23:31:20.123456789Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMilliseconds()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:20.123456789Z\"~string\n)~timestamp^string_to_timestamp.getMilliseconds()~int^timestamp_to_milliseconds","type":"int"},{"original":{"name":"getMinutes","expr":"timestamp('2009-02-13T23:31:30Z').getMinutes()","value":{"int64Value":"31"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMinutes()~int^timestamp_to_minutes","type":"int"},{"original":{"name":"getMonth","expr":"timestamp('2009-02-13T23:31:30Z').getMonth()","value":{"int64Value":"1"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMonth()~int^timestamp_to_month","type":"int"},{"original":{"name":"getSeconds","expr":"timestamp('2009-02-13T23:31:30Z').getSeconds()","value":{"int64Value":"30"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getSeconds()~int^timestamp_to_seconds","type":"int"}]},{"name":"timestamp_selectors_tz","tests":[{"original":{"name":"getDate","expr":"timestamp('2009-02-13T23:31:30Z').getDate('Australia/Sydney')","value":{"int64Value":"14"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate(\n \"Australia/Sydney\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDate(\n \"Australia/Sydney\"~string\n)~int^timestamp_to_day_of_month_1_based_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_name_pos","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfMonth('US/Central')","value":{"int64Value":"12"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"US/Central\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"US/Central\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_numerical_pos","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfMonth('+11:00')","value":{"int64Value":"13"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"+11:00\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"+11:00\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_numerical_neg","expr":"timestamp('2009-02-13T02:00:00Z').getDayOfMonth('-02:30')","value":{"int64Value":"11"}},"ast":"timestamp(\n \"2009-02-13T02:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"-02:30\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T02:00:00Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"-02:30\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfMonth_name_neg","expr":"timestamp('2009-02-13T02:00:00Z').getDayOfMonth('America/St_Johns')","value":{"int64Value":"11"}},"ast":"timestamp(\n \"2009-02-13T02:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n \"America/St_Johns\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T02:00:00Z\"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n \"America/St_Johns\"~string\n)~int^timestamp_to_day_of_month_with_tz","type":"int"},{"original":{"name":"getDayOfWeek","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfWeek('UTC')","value":{"int64Value":"5"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek(\n \"UTC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfWeek(\n \"UTC\"~string\n)~int^timestamp_to_day_of_week_with_tz","type":"int"},{"original":{"name":"getDayOfYear","expr":"timestamp('2009-02-13T23:31:30Z').getDayOfYear('US/Central')","value":{"int64Value":"43"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear(\n \"US/Central\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getDayOfYear(\n \"US/Central\"~string\n)~int^timestamp_to_day_of_year_with_tz","type":"int"},{"original":{"name":"getFullYear","expr":"timestamp('2009-02-13T23:31:30Z').getFullYear('-09:30')","value":{"int64Value":"2009"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear(\n \"-09:30\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getFullYear(\n \"-09:30\"~string\n)~int^timestamp_to_year_with_tz","type":"int"},{"original":{"name":"getHours","expr":"timestamp('2009-02-13T23:31:30Z').getHours('02:00')","value":{"int64Value":"1"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours(\n \"02:00\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getHours(\n \"02:00\"~string\n)~int^timestamp_to_hours_with_tz","type":"int"},{"original":{"name":"getMinutes","expr":"timestamp('2009-02-13T23:31:30Z').getMinutes('Asia/Kathmandu')","value":{"int64Value":"16"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes(\n \"Asia/Kathmandu\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMinutes(\n \"Asia/Kathmandu\"~string\n)~int^timestamp_to_minutes_with_tz","type":"int"},{"original":{"name":"getMonth","expr":"timestamp('2009-02-13T23:31:30Z').getMonth('UTC')","value":{"int64Value":"1"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth(\n \"UTC\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getMonth(\n \"UTC\"~string\n)~int^timestamp_to_month_with_tz","type":"int"},{"original":{"name":"getSeconds","expr":"timestamp('2009-02-13T23:31:30Z').getSeconds('-00:00')","value":{"int64Value":"30"}},"ast":"timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds(\n \"-00:00\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"2009-02-13T23:31:30Z\"~string\n)~timestamp^string_to_timestamp.getSeconds(\n \"-00:00\"~string\n)~int^timestamp_to_seconds_tz","type":"int"}]},{"name":"timestamp_equality","tests":[{"original":{"name":"eq_same","expr":"timestamp('2009-02-13T23:31:30Z') == timestamp('2009-02-13T23:31:30Z')","value":{"boolValue":true}},"ast":"_==_(\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"eq_diff","expr":"timestamp('2009-02-13T23:31:29Z') == timestamp('2009-02-13T23:31:30Z')","value":{"boolValue":false}},"ast":"_==_(\n timestamp(\n \"2009-02-13T23:31:29Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:31:30Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n timestamp(\n \"2009-02-13T23:31:29Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:31:30Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"neq_same","expr":"timestamp('1945-05-07T02:41:00Z') != timestamp('1945-05-07T02:41:00Z')","value":{"boolValue":false}},"ast":"_!=_(\n timestamp(\n \"1945-05-07T02:41:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"1945-05-07T02:41:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n timestamp(\n \"1945-05-07T02:41:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"1945-05-07T02:41:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals","type":"bool"},{"original":{"name":"neq_diff","expr":"timestamp('2000-01-01T00:00:00Z') != timestamp('2001-01-01T00:00:00Z')","value":{"boolValue":true}},"ast":"_!=_(\n timestamp(\n \"2000-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n timestamp(\n \"2000-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals","type":"bool"}]},{"name":"duration_equality","tests":[{"original":{"name":"eq_same","expr":"duration('123s') == duration('123s')","value":{"boolValue":true}},"ast":"_==_(\n duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"123s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n duration(\n \"123s\"~string\n )~duration^string_to_duration,\n duration(\n \"123s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"eq_diff","expr":"duration('60s') == duration('3600s')","value":{"boolValue":false}},"ast":"_==_(\n duration(\n \"60s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"3600s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n duration(\n \"60s\"~string\n )~duration^string_to_duration,\n duration(\n \"3600s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"neq_same","expr":"duration('604800s') != duration('604800s')","value":{"boolValue":false}},"ast":"_!=_(\n duration(\n \"604800s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"604800s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n duration(\n \"604800s\"~string\n )~duration^string_to_duration,\n duration(\n \"604800s\"~string\n )~duration^string_to_duration\n)~bool^not_equals","type":"bool"},{"original":{"name":"neq_diff","expr":"duration('86400s') != duration('86164s')","value":{"boolValue":true}},"ast":"_!=_(\n duration(\n \"86400s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"86164s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_!=_(\n duration(\n \"86400s\"~string\n )~duration^string_to_duration,\n duration(\n \"86164s\"~string\n )~duration^string_to_duration\n)~bool^not_equals","type":"bool"}]},{"name":"timestamp_arithmetic","tests":[{"original":{"name":"add_duration_to_time","expr":"timestamp('2009-02-13T23:00:00Z') + duration('240s') == timestamp('2009-02-13T23:04:00Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"240s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:04:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"240s\"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n \"2009-02-13T23:04:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"add_time_to_duration","expr":"duration('120s') + timestamp('2009-02-13T23:01:00Z') == timestamp('2009-02-13T23:03:00Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n duration(\n \"120s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:01:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:03:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n duration(\n \"120s\"~string\n )~duration^string_to_duration,\n timestamp(\n \"2009-02-13T23:01:00Z\"~string\n )~timestamp^string_to_timestamp\n )~timestamp^add_duration_timestamp,\n timestamp(\n \"2009-02-13T23:03:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"add_duration_to_duration","expr":"duration('600s') + duration('50s') == duration('650s')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n duration(\n \"600s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"50s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"650s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n duration(\n \"600s\"~string\n )~duration^string_to_duration,\n duration(\n \"50s\"~string\n )~duration^string_to_duration\n )~duration^add_duration_duration,\n duration(\n \"650s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"add_time_to_duration_nanos_negative","expr":"timestamp('0001-01-01T00:00:01.000000001Z') + duration('-999999999ns') == timestamp('0001-01-01T00:00:00.000000002Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.000000001Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-999999999ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"0001-01-01T00:00:00.000000002Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.000000001Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"-999999999ns\"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n \"0001-01-01T00:00:00.000000002Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"add_time_to_duration_nanos_positive","expr":"timestamp('0001-01-01T00:00:01.999999999Z') + duration('999999999ns') == timestamp('0001-01-01T00:00:02.999999998Z')","value":{"boolValue":true}},"ast":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"999999999ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"0001-01-01T00:00:02.999999998Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _+_(\n timestamp(\n \"0001-01-01T00:00:01.999999999Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"999999999ns\"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n \"0001-01-01T00:00:02.999999998Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"subtract_duration_from_time","expr":"timestamp('2009-02-13T23:10:00Z') - duration('600s') == timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:10:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"600s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:10:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"600s\"~string\n )~duration^string_to_duration\n )~timestamp^subtract_timestamp_duration,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^equals","type":"bool"},{"original":{"name":"subtract_time_from_time","expr":"timestamp('2009-02-13T23:31:00Z') - timestamp('2009-02-13T23:29:00Z') == duration('120s')","value":{"boolValue":true}},"ast":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:31:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:29:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"120s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _-_(\n timestamp(\n \"2009-02-13T23:31:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:29:00Z\"~string\n )~timestamp^string_to_timestamp\n )~duration^subtract_timestamp_timestamp,\n duration(\n \"120s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"},{"original":{"name":"subtract_duration_from_duration","expr":"duration('900s') - duration('42s') == duration('858s')","value":{"boolValue":true}},"ast":"_==_(\n _-_(\n duration(\n \"900s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"42s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"858s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n _-_(\n duration(\n \"900s\"~string\n )~duration^string_to_duration,\n duration(\n \"42s\"~string\n )~duration^string_to_duration\n )~duration^subtract_duration_duration,\n duration(\n \"858s\"~string\n )~duration^string_to_duration\n)~bool^equals","type":"bool"}]},{"name":"comparisons","tests":[{"original":{"name":"leq_timestamp_true","expr":"timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp","type":"bool"},{"original":{"name":"leq_timestamp_false","expr":"timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T22:59:59Z')","value":{"boolValue":false}},"ast":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T22:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T22:59:59Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp","type":"bool"},{"original":{"name":"leq_duration_true","expr":"duration('200s') \u003c= duration('200s')","value":{"boolValue":true}},"ast":"_\u003c=_(\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n duration(\n \"200s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration","type":"bool"},{"original":{"name":"leq_duration_false","expr":"duration('300s') \u003c= duration('200s')","value":{"boolValue":false}},"ast":"_\u003c=_(\n duration(\n \"300s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c=_(\n duration(\n \"300s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration","type":"bool"},{"original":{"name":"less_timestamp_true","expr":"timestamp('2009-02-13T23:00:00Z') \u003c timestamp('2009-03-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003c_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-03-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-03-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^less_timestamp","type":"bool"},{"original":{"name":"less_duration_true","expr":"duration('200s') \u003c duration('300s')","value":{"boolValue":true}},"ast":"_\u003c_(\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"300s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003c_(\n duration(\n \"200s\"~string\n )~duration^string_to_duration,\n duration(\n \"300s\"~string\n )~duration^string_to_duration\n)~bool^less_duration","type":"bool"},{"original":{"name":"geq_timestamp_true","expr":"timestamp('2009-02-13T23:00:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003e=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp","type":"bool"},{"original":{"name":"geq_timestamp_false","expr":"timestamp('2009-02-13T22:58:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":false}},"ast":"_\u003e=_(\n timestamp(\n \"2009-02-13T22:58:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n timestamp(\n \"2009-02-13T22:58:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp","type":"bool"},{"original":{"name":"geq_duration_true","expr":"duration('200s') \u003e= duration('200s')","value":{"boolValue":true}},"ast":"_\u003e=_(\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n duration(\n \"200s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration","type":"bool"},{"original":{"name":"geq_duration_false","expr":"duration('120s') \u003e= duration('200s')","value":{"boolValue":false}},"ast":"_\u003e=_(\n duration(\n \"120s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e=_(\n duration(\n \"120s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration","type":"bool"},{"original":{"name":"greater_timestamp_true","expr":"timestamp('2009-02-13T23:59:00Z') \u003e timestamp('2009-02-13T23:00:00Z')","value":{"boolValue":true}},"ast":"_\u003e_(\n timestamp(\n \"2009-02-13T23:59:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"2009-02-13T23:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n timestamp(\n \"2009-02-13T23:59:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"2009-02-13T23:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_timestamp","type":"bool"},{"original":{"name":"greater_duration_true","expr":"duration('300s') \u003e duration('200s')","value":{"boolValue":true}},"ast":"_\u003e_(\n duration(\n \"300s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_\u003e_(\n duration(\n \"300s\"~string\n )~duration^string_to_duration,\n duration(\n \"200s\"~string\n )~duration^string_to_duration\n)~bool^greater_duration","type":"bool"}]},{"name":"duration_converters","tests":[{"original":{"name":"get_hours","expr":"duration('10000s').getHours()","value":{"int64Value":"2"}},"ast":"duration(\n \"10000s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"10000s\"~string\n)~duration^string_to_duration.getHours()~int^duration_to_hours","type":"int"},{"original":{"name":"get_milliseconds","description":"Obtain the milliseconds component of the duration. Note, this is not the same as converting the duration to milliseconds. This behavior will be deprecated.","expr":"x.getMilliseconds()","typeEnv":[{"name":"x","ident":{"type":{"messageType":"google.protobuf.Duration"}}}],"bindings":{"x":{"value":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Duration","value":"123.321456789s"}}}},"value":{"int64Value":"321"}},"ast":"x^#*expr.Expr_IdentExpr#.getMilliseconds()^#*expr.Expr_CallExpr#","checkedAst":"x~duration^x.getMilliseconds()~int^duration_to_milliseconds","type":"int"},{"original":{"name":"get_minutes","expr":"duration('3730s').getMinutes()","value":{"int64Value":"62"}},"ast":"duration(\n \"3730s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"3730s\"~string\n)~duration^string_to_duration.getMinutes()~int^duration_to_minutes","type":"int"},{"original":{"name":"get_seconds","expr":"duration('3730s').getSeconds()","value":{"int64Value":"3730"}},"ast":"duration(\n \"3730s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"3730s\"~string\n)~duration^string_to_duration.getSeconds()~int^duration_to_seconds","type":"int"}]},{"name":"timestamp_range","tests":[{"original":{"name":"from_string_under","expr":"timestamp('0000-01-01T00:00:00Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"timestamp(\n \"0000-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"0000-01-01T00:00:00Z\"~string\n)~timestamp^string_to_timestamp","type":"timestamp"},{"original":{"name":"from_string_over","expr":"timestamp('10000-01-01T00:00:00Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"timestamp(\n \"10000-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"timestamp(\n \"10000-01-01T00:00:00Z\"~string\n)~timestamp^string_to_timestamp","type":"timestamp"},{"original":{"name":"add_duration_under","expr":"timestamp('0001-01-01T00:00:00Z') + duration('-1s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-1s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"-1s\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"add_duration_over","expr":"timestamp('9999-12-31T23:59:59Z') + duration('1s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"9999-12-31T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"1s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"9999-12-31T23:59:59Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"1s\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"add_duration_nanos_over","expr":"timestamp('9999-12-31T23:59:59.999999999Z') + duration('1ns')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"1ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"9999-12-31T23:59:59.999999999Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"1ns\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"add_duration_nanos_under","expr":"timestamp('0001-01-01T00:00:00Z') + duration('-1ns')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-1ns\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n duration(\n \"-1ns\"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration","type":"timestamp"},{"original":{"name":"sub_time_duration_over","expr":"timestamp('9999-12-31T23:59:59Z') - timestamp('0001-01-01T00:00:00Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n timestamp(\n \"9999-12-31T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n timestamp(\n \"9999-12-31T23:59:59Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp","type":"duration"},{"original":{"name":"sub_time_duration_under","expr":"timestamp('0001-01-01T00:00:00Z') - timestamp('9999-12-31T23:59:59Z')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n timestamp(\n \"0001-01-01T00:00:00Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n \"9999-12-31T23:59:59Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n timestamp(\n \"0001-01-01T00:00:00Z\"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n \"9999-12-31T23:59:59Z\"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp","type":"duration"}]},{"name":"duration_range","tests":[{"original":{"name":"from_string_under","expr":"duration('-320000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"duration(\n \"-320000000000s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"-320000000000s\"~string\n)~duration^string_to_duration","type":"duration"},{"original":{"name":"from_string_over","expr":"duration('320000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"duration(\n \"320000000000s\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"duration(\n \"320000000000s\"~string\n)~duration^string_to_duration","type":"duration"},{"original":{"name":"add_under","expr":"duration('-200000000000s') + duration('-200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration","type":"duration"},{"original":{"name":"add_over","expr":"duration('200000000000s') + duration('200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_+_(\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration","type":"duration"},{"original":{"name":"sub_under","expr":"duration('-200000000000s') - duration('200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration","type":"duration"},{"original":{"name":"sub_over","expr":"duration('200000000000s') - duration('-200000000000s')","evalError":{"errors":[{"message":"range"}]}},"ast":"_-_(\n duration(\n \"200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n \"-200000000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_-_(\n duration(\n \"200000000000s\"~string\n )~duration^string_to_duration,\n duration(\n \"-200000000000s\"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration","type":"duration"}]}]},{"name":"type_deductions","suites":[{"name":"constant_literals","tests":[{"original":{"name":"bool","expr":"true","typedResult":{"result":{"boolValue":true},"deducedType":{"primitive":"BOOL"}}},"ast":"true^#*expr.Constant_BoolValue#","checkedAst":"true~bool","type":"bool"},{"original":{"name":"int","expr":"42","typedResult":{"result":{"int64Value":"42"},"deducedType":{"primitive":"INT64"}}},"ast":"42^#*expr.Constant_Int64Value#","checkedAst":"42~int","type":"int"},{"original":{"name":"uint","expr":"42u","typedResult":{"result":{"uint64Value":"42"},"deducedType":{"primitive":"UINT64"}}},"ast":"42u^#*expr.Constant_Uint64Value#","checkedAst":"42u~uint","type":"uint"},{"original":{"name":"double","expr":"0.1","typedResult":{"result":{"doubleValue":0.1},"deducedType":{"primitive":"DOUBLE"}}},"ast":"0.1^#*expr.Constant_DoubleValue#","checkedAst":"0.1~double","type":"double"},{"original":{"name":"string","expr":"\"test\"","typedResult":{"result":{"stringValue":"test"},"deducedType":{"primitive":"STRING"}}},"ast":"\"test\"^#*expr.Constant_StringValue#","checkedAst":"\"test\"~string","type":"string"},{"original":{"name":"bytes","expr":"b\"test\"","typedResult":{"result":{"bytesValue":"dGVzdA=="},"deducedType":{"primitive":"BYTES"}}},"ast":"b\"test\"^#*expr.Constant_BytesValue#","checkedAst":"b\"test\"~bytes","type":"bytes"},{"original":{"name":"null","expr":"null","typedResult":{"result":{"nullValue":null},"deducedType":{"null":null}}},"ast":"null^#*expr.Constant_NullValue#","checkedAst":"null~null","type":"null"}]},{"name":"complex_initializers","tests":[{"original":{"name":"list","expr":"[1]","typedResult":{"result":{"listValue":{"values":[{"int64Value":"1"}]}},"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"[\n 1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n 1~int\n]~list(int)","type":"list(int)"},{"original":{"name":"map","expr":"{'abc': 123}","typedResult":{"result":{"mapValue":{"entries":[{"key":{"stringValue":"abc"},"value":{"int64Value":"123"}}]}},"deducedType":{"mapType":{"keyType":{"primitive":"STRING"},"valueType":{"primitive":"INT64"}}}}},"ast":"{\n \"abc\"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"{\n \"abc\"~string:123~int\n}~map(string, int)","type":"map(string, int)"},{"original":{"name":"struct","expr":"TestAllTypes{single_int64: 1}","container":"cel.expr.conformance.proto3","typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes","singleInt64":"1"}},"deducedType":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}},"ast":"TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes","type":"cel.expr.conformance.proto3.TestAllTypes"}]},{"name":"field_access","tests":[{"original":{"name":"int_field","expr":"TestAllTypes{single_int64: 1}.single_int64","container":"cel.expr.conformance.proto3","typedResult":{"result":{"int64Value":"1"},"deducedType":{"primitive":"INT64"}}},"ast":"TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int","type":"int"},{"original":{"name":"repeated_int_field","expr":"TestAllTypes{}.repeated_int64","container":"cel.expr.conformance.proto3","typedResult":{"result":{"listValue":{}},"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)","type":"list(int)"},{"original":{"name":"map_bool_int","expr":"TestAllTypes{}.map_bool_int64","container":"cel.expr.conformance.proto3","typedResult":{"result":{"mapValue":{}},"deducedType":{"mapType":{"keyType":{"primitive":"BOOL"},"valueType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_bool_int64^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_bool_int64~map(bool, int)","type":"map(bool, int)"},{"original":{"name":"enum_field","expr":"TestAllTypes{}.standalone_enum","container":"cel.expr.conformance.proto3","typedResult":{"result":{"int64Value":"0"},"deducedType":{"primitive":"INT64"}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int","type":"int"},{"original":{"name":"repeated_enum_field","expr":"TestAllTypes{}.repeated_nested_enum","container":"cel.expr.conformance.proto3","typedResult":{"result":{"listValue":{}},"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)","type":"list(int)"},{"original":{"name":"enum_map_field","expr":"TestAllTypes{}.map_int32_enum","container":"cel.expr.conformance.proto3","typedResult":{"result":{"mapValue":{}},"deducedType":{"mapType":{"keyType":{"primitive":"INT64"},"valueType":{"primitive":"INT64"}}}}},"ast":"TestAllTypes{}^#*expr.Expr_StructExpr#.map_int32_enum^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_int32_enum~map(int, int)","type":"map(int, int)"}]},{"name":"indexing","tests":[{"original":{"name":"list","expr":"['foo'][0]","typedResult":{"result":{"stringValue":"foo"},"deducedType":{"primitive":"STRING"}}},"ast":"_[_](\n [\n \"foo\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n \"foo\"~string\n ]~list(string),\n 0~int\n)~string^index_list","type":"string"},{"original":{"name":"map","expr":"{'abc': 123}['abc']","typedResult":{"result":{"int64Value":"123"},"deducedType":{"primitive":"INT64"}}},"ast":"_[_](\n {\n \"abc\"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n \"abc\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n {\n \"abc\"~string:123~int\n }~map(string, int),\n \"abc\"~string\n)~int^index_map","type":"int"}]},{"name":"functions","tests":[{"original":{"name":"nested_calls","expr":"('foo' + 'bar').startsWith('foo')","typedResult":{"result":{"boolValue":true},"deducedType":{"primitive":"BOOL"}}},"ast":"_+_(\n \"foo\"^#*expr.Constant_StringValue#,\n \"bar\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.startsWith(\n \"foo\"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n \"foo\"~string,\n \"bar\"~string\n)~string^add_string.startsWith(\n \"foo\"~string\n)~bool^starts_with_string","type":"bool"},{"original":{"name":"function_result_type","expr":"fn('abc', 123)","checkOnly":true,"typeEnv":[{"name":"fn","function":{"overloads":[{"overloadId":"fn_string_int","params":[{"primitive":"STRING"},{"primitive":"INT64"}],"resultType":{"primitive":"STRING"}}]}}],"typedResult":{"deducedType":{"primitive":"STRING"}}},"ast":"fn(\n \"abc\"^#*expr.Constant_StringValue#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"fn(\n \"abc\"~string,\n 123~int\n)~string^fn_string_int","type":"string"}]},{"name":"flexible_type_parameter_assignment","tests":[{"original":{"name":"list_parameter","expr":"[[], [[]], [[[]]], [[[[]]]]]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"dyn":{}}}}}}}}}}}}}},"ast":"[\n []^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n []~list(list(list(list(dyn)))),\n [\n []~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))","type":"list(list(list(list(list(dyn)))))"},{"original":{"name":"list_parameter_order_independent","expr":"[[[[[]]]], [], [[[]]]]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"listType":{"elemType":{"dyn":{}}}}}}}}}}}}}},"ast":"[\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n []~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))","type":"list(list(list(list(list(dyn)))))"},{"original":{"name":"comprehension_type_var_aliasing","expr":"msg.repeated_nested_message.map(x, x).map(y, y.bb)","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"primitive":"INT64"}}}}},"ast":"__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n y^#*expr.Expr_IdentExpr#.bb^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#","checkedAst":"__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result,\n [\n x~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^x\n ]~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n // Result\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result)~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n y~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^y.bb~int\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)","type":"list(int)"},{"original":{"name":"overload_type_var_aliasing","expr":"([] + msg.repeated_nested_message + [])[0].bb","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"primitive":"INT64"}}},"ast":"_[_](\n _+_(\n _+_(\n []^#*expr.Expr_ListExpr#,\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.bb^#*expr.Expr_SelectExpr#","checkedAst":"_[_](\n _+_(\n _+_(\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n 0~int\n)~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^index_list.bb~int","type":"int"},{"original":{"name":"unconstrained_type_var_as_dyn","expr":"([].map(x,x))[0].foo","checkOnly":true,"typedResult":{"deducedType":{"dyn":{}}}},"ast":"_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.foo^#*expr.Expr_SelectExpr#","checkedAst":"_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []~list(dyn),\n // Accumulator\n @result,\n // Init\n []~list(dyn),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(dyn)^@result,\n [\n x~dyn^x\n ]~list(dyn)\n )~list(dyn)^add_list,\n // Result\n @result~list(dyn)^@result)~list(dyn),\n 0~int\n)~dyn^index_list.foo~dyn","type":"dyn"},{"original":{"name":"list_parameters_do_not_unify","expr":"[msg.single_int64_wrapper, msg.single_string_wrapper]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"dyn":{}}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_string_wrapper~wrapper(string)\n]~list(dyn)","type":"list(dyn)"},{"original":{"name":"optional_none","expr":"[optional.none(), optional.of(1)]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"primitive":"INT64"}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(int))","type":"list(optional_type(int))"},{"original":{"name":"optional_none_2","expr":"[optional.of(1), optional.none()]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"primitive":"INT64"}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n]~list(optional_type(int))","type":"list(optional_type(int))"},{"original":{"name":"optional_dyn_promotion","expr":"[optional.of(1), optional.of(dyn(1))]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"dyn":{}}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of\n]~list(optional_type(dyn))","type":"list(optional_type(dyn))"},{"original":{"name":"optional_dyn_promotion_2","expr":"[optional.of(dyn(1)), optional.of(1)]","checkOnly":true,"typedResult":{"deducedType":{"listType":{"elemType":{"abstractType":{"name":"optional_type","parameterTypes":[{"dyn":{}}]}}}}}},"ast":"[\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(dyn))","type":"list(optional_type(dyn))"},{"original":{"name":"optional_in_ternary","expr":"true ? optional.of(dyn(1)) : optional.of(1)","checkOnly":true,"typedResult":{"deducedType":{"abstractType":{"name":"optional_type","parameterTypes":[{"dyn":{}}]}}}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~optional_type(dyn)^conditional","type":"optional_type(dyn)"}]},{"name":"wrappers","tests":[{"original":{"name":"wrapper_promotion","expr":"[msg.single_int64_wrapper, msg.single_int64]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"wrapper":"INT64"}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(wrapper(int))","type":"list(wrapper(int))"},{"original":{"name":"wrapper_promotion_2","expr":"[msg.single_int64, msg.single_int64_wrapper]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"wrapper":"INT64"}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int)\n]~list(int)","type":"list(int)"},{"original":{"name":"wrapper_dyn_promotion","expr":"[msg.single_int64_wrapper, msg.single_int64, dyn(1)]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"dyn":{}}}}}},"ast":"[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n dyn(\n 1~int\n )~dyn^to_dyn\n]~list(dyn)","type":"list(dyn)"},{"original":{"name":"wrapper_dyn_promotion_2","expr":"[dyn(1), msg.single_int64_wrapper, msg.single_int64]","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"listType":{"elemType":{"dyn":{}}}}}},"ast":"[\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#","checkedAst":"[\n dyn(\n 1~int\n )~dyn^to_dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(dyn)","type":"list(dyn)"},{"original":{"name":"wrapper_primitive_assignable","expr":"msg.single_int64_wrapper + 1","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"primitive":"INT64"}}},"ast":"_+_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_+_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 1~int\n)~int^add_int64","type":"int"},{"original":{"name":"wrapper_null_assignable","expr":"msg.single_int64_wrapper == null","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"primitive":"BOOL"}}},"ast":"_==_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals","type":"bool"},{"original":{"name":"wrapper_ternary_parameter_assignment","expr":"false ? msg.single_int64_wrapper : null","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"wrapper":"INT64"}}},"ast":"_?_:_(\n false^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n false~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~wrapper(int)^conditional","type":"wrapper(int)"},{"original":{"name":"wrapper_ternary_parameter_assignment_2","expr":"true ? msg.single_int64_wrapper : 42","checkOnly":true,"typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"typedResult":{"deducedType":{"wrapper":"INT64"}}},"ast":"_?_:_(\n true^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_?_:_(\n true~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 42~int\n)~wrapper(int)^conditional","type":"wrapper(int)"}]},{"name":"type_parameters","tests":[{"original":{"name":"multiple_parameters_generality","expr":"[tuple(1, 2u, 3.0), tuple(dyn(1), dyn(2u), dyn(3.0))][0]","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}}],"typedResult":{"deducedType":{"abstractType":{"name":"tuple","parameterTypes":[{"dyn":{}},{"dyn":{}},{"dyn":{}}]}}}},"ast":"_[_](\n [\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(dyn, dyn, dyn)^tuple_T_U_V\n ]~list(tuple(dyn, dyn, dyn)),\n 0~int\n)~tuple(dyn, dyn, dyn)^index_list","type":"tuple(dyn, dyn, dyn)"},{"original":{"name":"multiple_parameters_generality_2","expr":"sort(tuple(dyn(1), 2u, 3.0))","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}},{"name":"sort","function":{"overloads":[{"overloadId":"sort_tuple_T_T_T","params":[{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"T"},{"typeParam":"T"}]}}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"T"},{"typeParam":"T"}]}}}]}}],"typedResult":{"deducedType":{"abstractType":{"name":"tuple","parameterTypes":[{"dyn":{}},{"dyn":{}},{"dyn":{}}]}}}},"ast":"sort(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"sort(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint,\n 3~double\n )~tuple(dyn, uint, double)^tuple_T_U_V\n)~tuple(dyn, dyn, dyn)^sort_tuple_T_T_T","type":"tuple(dyn, dyn, dyn)"},{"original":{"name":"multiple_parameters_parameterized_ovl","expr":"tuple(1, 2u, 3.0) == tuple(1, dyn(2u), dyn(3.0))","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}}],"typedResult":{"deducedType":{"primitive":"BOOL"}}},"ast":"_==_(\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n 1~int,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(int, dyn, dyn)^tuple_T_U_V\n)~bool^equals","type":"bool"},{"original":{"name":"multiple_parameters_parameterized_ovl_2","expr":"tuple(dyn(1), dyn(2u), 3.0) == tuple(1, 2u, 3.0)","checkOnly":true,"typeEnv":[{"name":"tuple","function":{"overloads":[{"overloadId":"tuple_T_U_V","params":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}],"resultType":{"abstractType":{"name":"tuple","parameterTypes":[{"typeParam":"T"},{"typeParam":"U"},{"typeParam":"V"}]}}}]}}],"typedResult":{"deducedType":{"primitive":"BOOL"}}},"ast":"_==_(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 3~double\n )~tuple(dyn, dyn, double)^tuple_T_U_V,\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V\n)~bool^equals","type":"bool"}]},{"name":"legacy_nullable_types","tests":[{"original":{"name":"null_assignable_to_message_parameter_candidate","expr":"[msg, null][0]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}}}},"typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}},"deducedType":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}},"ast":"_[_](\n [\n msg^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"},{"original":{"name":"null_assignable_to_duration_parameter_candidate","expr":"[msg.single_duration, null][0]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}}}},"typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Duration","value":"0s"}},"deducedType":{"wellKnown":"DURATION"}}},"ast":"_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_duration^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_duration~duration,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"},{"original":{"name":"null_assignable_to_timestamp_parameter_candidate","expr":"[msg.single_timestamp, null][0]","typeEnv":[{"name":"msg","ident":{"type":{"messageType":"cel.expr.conformance.proto3.TestAllTypes"}}}],"bindings":{"msg":{"value":{"objectValue":{"@type":"type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"}}}},"typedResult":{"result":{"objectValue":{"@type":"type.googleapis.com/google.protobuf.Timestamp","value":"1970-01-01T00:00:00Z"}},"deducedType":{"wellKnown":"TIMESTAMP"}}},"ast":"_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_timestamp^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_timestamp~timestamp,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"},{"original":{"name":"null_assignable_to_abstract_parameter_candidate","expr":"[optional.of(1), null][0]","checkOnly":true,"typedResult":{"deducedType":{"abstractType":{"name":"optional_type","parameterTypes":[{"primitive":"INT64"}]}}}},"ast":"_[_](\n [\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#","checkedAst":"_[_](\n [\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list","type":"null"}]}]},{"name":"unknowns"},{"name":"wrappers","suites":[{"name":"bool","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.BoolValue{value: true}}.single_any","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.BoolValue{value: true}}.single_value","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_bool_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_bool_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"int32","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.Int32Value{value: 1}}.single_any","container":"cel.expr.conformance.proto3","value":{"int64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.Int32Value{value: 1}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_int32_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"int64","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.Int64Value{value: 1}}.single_any","container":"cel.expr.conformance.proto3","value":{"int64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json_number","expr":"TestAllTypes{single_value: google.protobuf.Int64Value{value: 1}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_json_string","expr":"TestAllTypes{single_value: google.protobuf.Int64Value{value: 9223372036854775807}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"9223372036854775807"}},"ast":"TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_int64_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_int64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"uint32","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.UInt32Value{value: 1u}}.single_any","container":"cel.expr.conformance.proto3","value":{"uint64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.UInt32Value{value: 1u}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_uint32_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_uint32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"uint64","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.UInt64Value{value: 1u}}.single_any","container":"cel.expr.conformance.proto3","value":{"uint64Value":"1"}},"ast":"TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json_number","expr":"TestAllTypes{single_value: google.protobuf.UInt64Value{value: 1u}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_json_string","expr":"TestAllTypes{single_value: google.protobuf.UInt64Value{value: 18446744073709551615u}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"18446744073709551615"}},"ast":"TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_uint64_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_uint64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"float","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.FloatValue{value: 1.0}}.single_any","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.FloatValue{value: 1.0}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_float_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_float_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"double","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.DoubleValue{value: 1.0}}.single_any","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.DoubleValue{value: 1.0}}.single_value","container":"cel.expr.conformance.proto3","value":{"doubleValue":1}},"ast":"TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_double_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_double_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"bytes","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.BytesValue{value: b'foo'}}.single_any","container":"cel.expr.conformance.proto3","value":{"bytesValue":"Zm9v"}},"ast":"TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b\"foo\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b\"foo\"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.BytesValue{value: b'foo'}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"Zm9v"}},"ast":"TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b\"foo\"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b\"foo\"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_bytes_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_bytes_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"string","tests":[{"original":{"name":"to_any","expr":"TestAllTypes{single_any: google.protobuf.StringValue{value: 'foo'}}.single_any","container":"cel.expr.conformance.proto3","value":{"stringValue":"foo"}},"ast":"TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:\"foo\"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"},{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.StringValue{value: 'foo'}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"foo"}},"ast":"TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:\"foo\"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:\"foo\"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"},{"original":{"name":"to_null","expr":"TestAllTypes{single_string_wrapper: null} == TestAllTypes{}","container":"cel.expr.conformance.proto3","value":{"boolValue":true}},"ast":"_==_(\n TestAllTypes{\n single_string_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#","checkedAst":"_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals","type":"bool"}]},{"name":"value","tests":[{"original":{"name":"default_to_json","expr":"TestAllTypes{single_any: TestAllTypes{}.single_value}.single_any","container":"cel.expr.conformance.proto3","value":{"nullValue":null}},"ast":"TestAllTypes{\n single_any:TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"list_value","tests":[{"original":{"name":"literal_to_any","expr":"TestAllTypes{single_any: []}.single_any","container":"cel.expr.conformance.proto3","value":{"listValue":{}}},"ast":"TestAllTypes{\n single_any:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"struct","tests":[{"original":{"name":"literal_to_any","expr":"TestAllTypes{single_any: {}}.single_any","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_any:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_any:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any","type":"any"}]},{"name":"field_mask","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.FieldMask{paths: ['foo', 'bar']}}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"foo,bar"}},"ast":"TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n \"foo\"^#*expr.Constant_StringValue#,\n \"bar\"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n \"foo\"~string,\n \"bar\"~string\n ]~list(string)\n }~google.protobuf.FieldMask^google.protobuf.FieldMask\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"duration","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: duration('1000000s')}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"1000000s"}},"ast":"TestAllTypes{\n single_value:duration(\n \"1000000s\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:duration(\n \"1000000s\"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"timestamp","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: timestamp('9999-12-31T23:59:59.999999999Z')}.single_value","container":"cel.expr.conformance.proto3","value":{"stringValue":"9999-12-31T23:59:59.999999999Z"}},"ast":"TestAllTypes{\n single_value:timestamp(\n \"9999-12-31T23:59:59.999999999Z\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:timestamp(\n \"9999-12-31T23:59:59.999999999Z\"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]},{"name":"empty","tests":[{"original":{"name":"to_json","expr":"TestAllTypes{single_value: google.protobuf.Empty{}}.single_value","container":"cel.expr.conformance.proto3","value":{"mapValue":{}}},"ast":"TestAllTypes{\n single_value:google.protobuf.Empty{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#","checkedAst":"cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Empty{}~google.protobuf.Empty^google.protobuf.Empty\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn","type":"dyn"}]}]}]} as const; +import type { SerializedIncrementalTestSuite } from "./tests.js"; +export const tests: SerializedIncrementalTestSuite = { + name: "conformance", + suites: [ + { + name: "basic", + suites: [ + { + name: "self_eval_zeroish", + tests: [ + { + original: { + name: "self_eval_int_zero", + expr: "0", + value: { int64Value: "0" }, + }, + ast: "0^#*expr.Constant_Int64Value#", + checkedAst: "0~int", + type: "int", + }, + { + original: { + name: "self_eval_uint_zero", + expr: "0u", + value: { uint64Value: "0" }, + }, + ast: "0u^#*expr.Constant_Uint64Value#", + checkedAst: "0u~uint", + type: "uint", + }, + { + original: { + name: "self_eval_uint_alias_zero", + expr: "0U", + value: { uint64Value: "0" }, + }, + ast: "0u^#*expr.Constant_Uint64Value#", + checkedAst: "0u~uint", + type: "uint", + }, + { + original: { + name: "self_eval_float_zero", + expr: "0.0", + value: { doubleValue: 0 }, + }, + ast: "0^#*expr.Constant_DoubleValue#", + checkedAst: "0~double", + type: "double", + }, + { + original: { + name: "self_eval_float_zerowithexp", + expr: "0e+0", + value: { doubleValue: 0 }, + }, + ast: "0^#*expr.Constant_DoubleValue#", + checkedAst: "0~double", + type: "double", + }, + { + original: { + name: "self_eval_string_empty", + expr: "''", + value: { stringValue: "" }, + }, + ast: '""^#*expr.Constant_StringValue#', + checkedAst: '""~string', + type: "string", + }, + { + original: { + name: "self_eval_string_empty_quotes", + expr: '""', + value: { stringValue: "" }, + }, + ast: '""^#*expr.Constant_StringValue#', + checkedAst: '""~string', + type: "string", + }, + { + original: { + name: "self_eval_string_raw_prefix", + expr: 'r""', + value: { stringValue: "" }, + }, + ast: '""^#*expr.Constant_StringValue#', + checkedAst: '""~string', + type: "string", + }, + { + original: { + name: "self_eval_bytes_empty", + expr: 'b""', + value: { bytesValue: "" }, + }, + ast: 'b""^#*expr.Constant_BytesValue#', + checkedAst: 'b""~bytes', + type: "bytes", + }, + { + original: { + name: "self_eval_bool_false", + expr: "false", + value: { boolValue: false }, + }, + ast: "false^#*expr.Constant_BoolValue#", + checkedAst: "false~bool", + type: "bool", + }, + { + original: { + name: "self_eval_null", + expr: "null", + value: { nullValue: null }, + }, + ast: "null^#*expr.Constant_NullValue#", + checkedAst: "null~null", + type: "null", + }, + { + original: { + name: "self_eval_empty_list", + expr: "[]", + value: { listValue: {} }, + }, + ast: "[]^#*expr.Expr_ListExpr#", + checkedAst: "[]~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "self_eval_empty_map", + expr: "{}", + value: { mapValue: {} }, + }, + ast: "{}^#*expr.Expr_StructExpr#", + checkedAst: "{}~map(dyn, dyn)", + type: "map(dyn, dyn)", + }, + { + original: { + name: "self_eval_string_raw_prefix_triple_double", + expr: 'r""""""', + value: { stringValue: "" }, + }, + ast: '""^#*expr.Constant_StringValue#', + checkedAst: '""~string', + type: "string", + }, + { + original: { + name: "self_eval_string_raw_prefix_triple_single", + expr: "r''''''", + value: { stringValue: "" }, + }, + ast: '""^#*expr.Constant_StringValue#', + checkedAst: '""~string', + type: "string", + }, + ], + }, + { + name: "self_eval_nonzeroish", + tests: [ + { + original: { + name: "self_eval_int_nonzero", + expr: "42", + value: { int64Value: "42" }, + }, + ast: "42^#*expr.Constant_Int64Value#", + checkedAst: "42~int", + type: "int", + }, + { + original: { + name: "self_eval_uint_nonzero", + expr: "123456789u", + value: { uint64Value: "123456789" }, + }, + ast: "123456789u^#*expr.Constant_Uint64Value#", + checkedAst: "123456789u~uint", + type: "uint", + }, + { + original: { + name: "self_eval_uint_alias_nonzero", + expr: "123456789U", + value: { uint64Value: "123456789" }, + }, + ast: "123456789u^#*expr.Constant_Uint64Value#", + checkedAst: "123456789u~uint", + type: "uint", + }, + { + original: { + name: "self_eval_int_negative_min", + expr: "-9223372036854775808", + value: { int64Value: "-9223372036854775808" }, + }, + ast: "-9223372036854775808^#*expr.Constant_Int64Value#", + checkedAst: "-9223372036854775808~int", + type: "int", + }, + { + original: { + name: "self_eval_float_negative_exp", + expr: "-2.3e+1", + value: { doubleValue: -23 }, + }, + ast: "-23^#*expr.Constant_DoubleValue#", + checkedAst: "-23~double", + type: "double", + }, + { + original: { + name: "self_eval_string_excl", + expr: '"!"', + value: { stringValue: "!" }, + }, + ast: '"!"^#*expr.Constant_StringValue#', + checkedAst: '"!"~string', + type: "string", + }, + { + original: { + name: "self_eval_string_escape", + expr: "'\\''", + value: { stringValue: "'" }, + }, + ast: '"\'"^#*expr.Constant_StringValue#', + checkedAst: '"\'"~string', + type: "string", + }, + { + original: { + name: "self_eval_bytes_escape", + expr: "b'ÿ'", + value: { bytesValue: "w78=" }, + }, + ast: 'b"ÿ"^#*expr.Constant_BytesValue#', + checkedAst: 'b"ÿ"~bytes', + type: "bytes", + }, + { + original: { + name: "self_eval_bytes_invalid_utf8", + expr: "b'\\000\\xff'", + value: { bytesValue: "AP8=" }, + }, + ast: 'b"\\x00\\xff"^#*expr.Constant_BytesValue#', + checkedAst: 'b"\\x00\\xff"~bytes', + type: "bytes", + }, + { + original: { + name: "self_eval_list_singleitem", + expr: "[-1]", + value: { listValue: { values: [{ int64Value: "-1" }] } }, + }, + ast: "[\n -1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#", + checkedAst: "[\n -1~int\n]~list(int)", + type: "list(int)", + }, + { + original: { + name: "self_eval_map_singleitem", + expr: '{"k":"v"}', + value: { + mapValue: { + entries: [ + { + key: { stringValue: "k" }, + value: { stringValue: "v" }, + }, + ], + }, + }, + }, + ast: '{\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: '{\n "k"~string:"v"~string\n}~map(string, string)', + type: "map(string, string)", + }, + { + original: { + name: "self_eval_bool_true", + expr: "true", + value: { boolValue: true }, + }, + ast: "true^#*expr.Constant_BoolValue#", + checkedAst: "true~bool", + type: "bool", + }, + { + original: { + name: "self_eval_int_hex", + expr: "0x55555555", + value: { int64Value: "1431655765" }, + }, + ast: "1431655765^#*expr.Constant_Int64Value#", + checkedAst: "1431655765~int", + type: "int", + }, + { + original: { + name: "self_eval_int_hex_negative", + expr: "-0x55555555", + value: { int64Value: "-1431655765" }, + }, + ast: "-1431655765^#*expr.Constant_Int64Value#", + checkedAst: "-1431655765~int", + type: "int", + }, + { + original: { + name: "self_eval_uint_hex", + expr: "0x55555555u", + value: { uint64Value: "1431655765" }, + }, + ast: "1431655765u^#*expr.Constant_Uint64Value#", + checkedAst: "1431655765u~uint", + type: "uint", + }, + { + original: { + name: "self_eval_uint_alias_hex", + expr: "0x55555555U", + value: { uint64Value: "1431655765" }, + }, + ast: "1431655765u^#*expr.Constant_Uint64Value#", + checkedAst: "1431655765u~uint", + type: "uint", + }, + { + original: { + name: "self_eval_unicode_escape_four", + expr: '"\\u270c"', + value: { stringValue: "✌" }, + }, + ast: '"✌"^#*expr.Constant_StringValue#', + checkedAst: '"✌"~string', + type: "string", + }, + { + original: { + name: "self_eval_unicode_escape_eight", + expr: '"\\U0001f431"', + value: { stringValue: "🐱" }, + }, + ast: '"🐱"^#*expr.Constant_StringValue#', + checkedAst: '"🐱"~string', + type: "string", + }, + { + original: { + name: "self_eval_ascii_escape_seq", + expr: '"\\a\\b\\f\\n\\r\\t\\v\\"\\\'\\\\"', + value: { stringValue: "\u0007\b\f\n\r\t\u000b\"'\\" }, + }, + ast: '"\\a\\b\\f\\n\\r\\t\\v\\"\'\\\\"^#*expr.Constant_StringValue#', + checkedAst: '"\\a\\b\\f\\n\\r\\t\\v\\"\'\\\\"~string', + type: "string", + }, + ], + }, + { + name: "variables", + tests: [ + { + original: { + name: "self_eval_bound_lookup", + expr: "x", + typeEnv: [ + { name: "x", ident: { type: { primitive: "INT64" } } }, + ], + bindings: { x: { value: { int64Value: "123" } } }, + value: { int64Value: "123" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~int^x", + type: "int", + }, + { + original: { + name: "self_eval_unbound_lookup", + description: + "An unbound variable should be marked as an error during execution. See google/cel-go#154", + expr: "x", + disableCheck: true, + evalError: { + errors: [ + { + message: "undeclared reference to 'x' (in container '')", + }, + ], + }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x\n | ^", + }, + { + original: { + name: "unbound_is_runtime_error", + description: + "Make sure we can short-circuit around an unbound variable.", + expr: "x || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n x^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'x' (in container '')\n | x || true\n | ^", + }, + ], + }, + { + name: "functions", + tests: [ + { + original: { + name: "binop", + expr: "1 + 1", + value: { int64Value: "2" }, + }, + ast: "_+_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 1~int,\n 1~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "unbound", + expr: "f_unknown(17)", + disableCheck: true, + evalError: { errors: [{ message: "unbound function" }] }, + }, + ast: "f_unknown(\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17)\n | .........^", + }, + { + original: { + name: "unbound_is_runtime_error", + expr: "f_unknown(17) || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n f_unknown(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:10: undeclared reference to 'f_unknown' (in container '')\n | f_unknown(17) || true\n | .........^", + }, + ], + }, + { + name: "reserved_const", + tests: [ + { + original: { + name: "false", + expr: "false", + typeEnv: [ + { name: "false", ident: { type: { primitive: "BOOL" } } }, + ], + bindings: { false: { value: { boolValue: true } } }, + value: { boolValue: false }, + }, + ast: "false^#*expr.Constant_BoolValue#", + checkedAst: "false~bool", + type: "bool", + }, + { + original: { + name: "true", + expr: "true", + typeEnv: [ + { name: "true", ident: { type: { primitive: "BOOL" } } }, + ], + bindings: { true: { value: { boolValue: false } } }, + value: { boolValue: true }, + }, + ast: "true^#*expr.Constant_BoolValue#", + checkedAst: "true~bool", + type: "bool", + }, + { + original: { + name: "null", + expr: "null", + typeEnv: [ + { name: "null", ident: { type: { primitive: "BOOL" } } }, + ], + bindings: { null: { value: { boolValue: true } } }, + value: { nullValue: null }, + }, + ast: "null^#*expr.Constant_NullValue#", + checkedAst: "null~null", + type: "null", + }, + ], + }, + ], + }, + { + name: "bindings_ext", + suites: [ + { + name: "bind", + tests: [ + { + original: { + name: "boolean_literal", + expr: "cel.bind(t, true, t)", + value: { boolValue: true }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.bind(\n t^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n t^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t~bool^t,\n // Result\n t~bool^t)~bool", + type: "bool", + }, + { + original: { + name: "string_concat", + expr: 'cel.bind(msg, "hello", msg + msg + msg)', + value: { stringValue: "hellohellohello" }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.bind(\n msg^#*expr.Expr_IdentExpr#,\n "hello"^#*expr.Constant_StringValue#,\n _+_(\n _+_(\n msg^#*expr.Expr_IdentExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n msg,\n // Init\n "hello"~string,\n // LoopCondition\n false~bool,\n // LoopStep\n msg~string^msg,\n // Result\n _+_(\n _+_(\n msg~string^msg,\n msg~string^msg\n )~string^add_string,\n msg~string^msg\n )~string^add_string)~string', + type: "string", + }, + { + original: { + name: "bind_nested", + expr: "cel.bind(t1, true, cel.bind(t2, true, t1 \u0026\u0026 t2))", + value: { boolValue: true }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.bind(\n t1^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.bind(\n t2^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#,\n _\u0026\u0026_(\n t1^#*expr.Expr_IdentExpr#,\n t2^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t1,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t1~bool^t1,\n // Result\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n t2,\n // Init\n true~bool,\n // LoopCondition\n false~bool,\n // LoopStep\n t2~bool^t2,\n // Result\n _\u0026\u0026_(\n t1~bool^t1,\n t2~bool^t2\n )~bool^logical_and)~bool)~bool", + type: "bool", + }, + { + original: { + name: "macro_exists", + expr: "cel.bind(valid_elems, [1, 2, 3], [3, 4, 5].exists(e, e in valid_elems))", + value: { boolValue: true }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool)~bool", + type: "bool", + }, + { + original: { + name: "macro_not_exists", + expr: "cel.bind(valid_elems, [1, 2, 3], ![4, 5].exists(e, e in valid_elems))", + value: { boolValue: true }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.bind(\n valid_elems^#*expr.Expr_IdentExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n @in(\n e^#*expr.Expr_IdentExpr#,\n valid_elems^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "__comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n valid_elems,\n // Init\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // LoopCondition\n false~bool,\n // LoopStep\n valid_elems~list(int)^valid_elems,\n // Result\n !_(\n __comprehension__(\n // Variable\n e,\n // Target\n [\n 4~int,\n 5~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n @in(\n e~int^e,\n valid_elems~list(int)^valid_elems\n )~bool^in_list\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_not)~bool", + type: "bool", + }, + ], + }, + ], + }, + { + name: "block_ext", + suites: [ + { + name: "basic", + tests: [ + { + original: { + name: "int_add", + expr: "cel.block([1, cel.index(0) + 1, cel.index(1) + 1, cel.index(2) + 1], cel.index(3))", + value: { int64Value: "4" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n 1^#*expr.Constant_Int64Value#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n 1~int,\n _+_(\n @index0~dyn^@index0,\n 1~int\n )~int^add_int64,\n _+_(\n @index1~dyn^@index1,\n 1~int\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(int),\n @index3~dyn^@index3\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "size_1", + expr: "cel.block([[1, 2], size(cel.index(0)), cel.index(1) + cel.index(1), cel.index(2) + 1], cel.index(3))", + value: { int64Value: "5" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index2~dyn^@index2,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "size_2", + expr: "cel.block([[1, 2], size(cel.index(0)), 2 + cel.index(1), cel.index(2) + cel.index(1), cel.index(3) + 1], cel.index(4))", + value: { int64Value: "7" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 2~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index2~dyn^@index2,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index3~dyn^@index3,\n 1~int\n )~int^add_int64\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "size_3", + expr: "cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), cel.index(1) + cel.index(1), cel.index(4) + cel.index(3), cel.index(5) + cel.index(3)], cel.index(6))", + value: { int64Value: "6" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index5~dyn^@index5,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "size_4", + expr: "cel.block([[0], size(cel.index(0)), [1, 2], size(cel.index(2)), [1, 2, 3], size(cel.index(4)), 5 + cel.index(1), cel.index(6) + cel.index(1), cel.index(7) + cel.index(3), cel.index(8) + cel.index(3), cel.index(9) + cel.index(5), cel.index(10) + cel.index(5)], cel.index(11))", + value: { int64Value: "17" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n size(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n [\n 0~int\n ]~list(int),\n size(\n @index0~dyn^@index0\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int\n ]~list(int),\n size(\n @index2~dyn^@index2\n )~int^size_bytes|size_list|size_map|size_string,\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n size(\n @index4~dyn^@index4\n )~int^size_bytes|size_list|size_map|size_string,\n _+_(\n 5~int,\n @index1~dyn^@index1\n )~int^add_int64,\n _+_(\n @index6~dyn^@index6,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index7~dyn^@index7,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index8~dyn^@index8,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index9~dyn^@index9,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index10~dyn^@index10,\n @index5~dyn^@index5\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "timestamp", + expr: "cel.block([timestamp(1000000000), int(cel.index(0)), timestamp(cel.index(1)), cel.index(2).getFullYear(), timestamp(50), int(cel.index(4)), timestamp(cel.index(5)), timestamp(200), int(cel.index(7)), timestamp(cel.index(8)), cel.index(9).getFullYear(), timestamp(75), int(cel.index(11)), timestamp(cel.index(12)), cel.index(13).getFullYear(), cel.index(3) + cel.index(14), cel.index(6).getFullYear(), cel.index(15) + cel.index(16), cel.index(17) + cel.index(3), cel.index(6).getSeconds(), cel.index(18) + cel.index(19), cel.index(20) + cel.index(10), cel.index(21) + cel.index(10), cel.index(13).getMinutes(), cel.index(22) + cel.index(23), cel.index(24) + cel.index(3)], cel.index(25))", + value: { int64Value: "13934" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 200^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n timestamp(\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n int(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 14^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 16^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 18^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 19^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 21^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp,\n int(\n @index0~dyn^@index0\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index1~dyn^@index1\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index2~dyn^@index2.getFullYear()~int^timestamp_to_year,\n timestamp(\n 50~int\n )~timestamp^int64_to_timestamp,\n int(\n @index4~dyn^@index4\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index5~dyn^@index5\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n timestamp(\n 200~int\n )~timestamp^int64_to_timestamp,\n int(\n @index7~dyn^@index7\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index8~dyn^@index8\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index9~dyn^@index9.getFullYear()~int^timestamp_to_year,\n timestamp(\n 75~int\n )~timestamp^int64_to_timestamp,\n int(\n @index11~dyn^@index11\n )~int^double_to_int64|duration_to_int64|int64_to_int64|string_to_int64|timestamp_to_int64|uint64_to_int64,\n timestamp(\n @index12~dyn^@index12\n )~timestamp^int64_to_timestamp|string_to_timestamp|timestamp_to_timestamp,\n @index13~dyn^@index13.getFullYear()~int^timestamp_to_year,\n _+_(\n @index3~dyn^@index3,\n @index14~dyn^@index14\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getFullYear()~int^timestamp_to_year,\n _+_(\n @index15~dyn^@index15,\n @index16~dyn^@index16\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index17~dyn^@index17,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index6~dyn^@index6.getSeconds()~int^duration_to_seconds|timestamp_to_seconds,\n _+_(\n @index18~dyn^@index18,\n @index19~dyn^@index19\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index20~dyn^@index20,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index21~dyn^@index21,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index13~dyn^@index13.getMinutes()~int^duration_to_minutes|timestamp_to_minutes,\n _+_(\n @index22~dyn^@index22,\n @index23~dyn^@index23\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index24~dyn^@index24,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index25~dyn^@index25\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "map_index", + expr: 'cel.block([{"a": 2}, cel.index(0)["a"], cel.index(1) * cel.index(1), cel.index(1) + cel.index(2)], cel.index(3))', + value: { int64Value: "6" }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "a"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "a"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n {\n "a"~string:2~int\n }~map(string, int),\n _[_](\n @index0~dyn^@index0,\n "a"~string\n )~dyn^index_map|optional_map_index_value,\n _*_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~dyn^multiply_double|multiply_int64|multiply_uint64,\n _+_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index3~dyn^@index3\n)~dyn^cel_block_list', + type: "dyn", + }, + { + original: { + name: "nested_map_construction", + expr: 'cel.block([{"b": 1}, {"e": cel.index(0)}], {"a": cel.index(0), "c": cel.index(0), "d": cel.index(1), "e": cel.index(1)})', + value: { + mapValue: { + entries: [ + { + key: { stringValue: "a" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "b" }, + value: { int64Value: "1" }, + }, + ], + }, + }, + }, + { + key: { stringValue: "c" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "b" }, + value: { int64Value: "1" }, + }, + ], + }, + }, + }, + { + key: { stringValue: "d" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "e" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "b" }, + value: { int64Value: "1" }, + }, + ], + }, + }, + }, + ], + }, + }, + }, + { + key: { stringValue: "e" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "e" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "b" }, + value: { int64Value: "1" }, + }, + ], + }, + }, + }, + ], + }, + }, + }, + ], + }, + }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "b"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "e"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n {\n "a"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "c"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "d"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "e"^#*expr.Constant_StringValue#:cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n {\n "b"~string:1~int\n }~map(string, int),\n {\n "e"~string:@index0~dyn^@index0\n }~map(string, dyn)\n ]~list(map(string, dyn)),\n {\n "a"~string:@index0~dyn^@index0,\n "c"~string:@index0~dyn^@index0,\n "d"~string:@index1~dyn^@index1,\n "e"~string:@index1~dyn^@index1\n }~map(string, dyn)\n)~map(string, dyn)^cel_block_list', + type: "map(string, dyn)", + }, + { + original: { + name: "nested_list_construction", + expr: "cel.block([[1, 2, 3, 4], [1, 2], [cel.index(1), cel.index(0)]], [1, cel.index(0), 2, cel.index(0), 5, cel.index(0), 7, cel.index(2), cel.index(1)])", + value: { + listValue: { + values: [ + { int64Value: "1" }, + { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + { int64Value: "2" }, + { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + { int64Value: "5" }, + { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + { int64Value: "7" }, + { + listValue: { + values: [ + { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + ], + }, + }, + { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + ], + }, + }, + { + listValue: { + values: [{ int64Value: "1" }, { int64Value: "2" }], + }, + }, + ], + }, + }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n [\n 1~int,\n 2~int\n ]~list(int),\n [\n @index1~dyn^@index1,\n @index0~dyn^@index0\n ]~list(dyn)\n ]~list(list(dyn)),\n [\n 1~int,\n @index0~dyn^@index0,\n 2~int,\n @index0~dyn^@index0,\n 5~int,\n @index0~dyn^@index0,\n 7~int,\n @index2~dyn^@index2,\n @index1~dyn^@index1\n ]~list(dyn)\n)~list(dyn)^cel_block_list", + type: "list(dyn)", + }, + { + original: { + name: "select", + expr: "cel.block([msg.single_int64, cel.index(0) + cel.index(0)], cel.index(1))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "6" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index0~dyn^@index0,\n @index0~dyn^@index0\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index1~dyn^@index1\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "select_nested_1", + expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, cel.index(1).single_int32, cel.index(2) + cel.index(3), cel.index(4) + cel.index(2), msg.single_int64, cel.index(5) + cel.index(6), cel.index(1).oneof_type, cel.index(8).payload, cel.index(9).single_int64, cel.index(7) + cel.index(10)], cel.index(11))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "31" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int32~dyn,\n _+_(\n @index2~dyn^@index2,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index2~dyn^@index2\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n @index1~dyn^@index1.oneof_type~dyn,\n @index8~dyn^@index8.payload~dyn,\n @index9~dyn^@index9.single_int64~dyn,\n _+_(\n @index7~dyn^@index7,\n @index10~dyn^@index10\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index11~dyn^@index11\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "select_nested_2", + expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).oneof_type, cel.index(2).payload, cel.index(3).oneof_type, cel.index(4).payload, cel.index(5).oneof_type, cel.index(6).payload, cel.index(7).single_bool, true || cel.index(8), cel.index(4).child, cel.index(10).child, cel.index(11).payload, cel.index(12).single_bool], cel.index(9) || cel.index(13))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { boolValue: true }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#,\n _||_(\n true^#*expr.Constant_BoolValue#,\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.child^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_bool^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _||_(\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.oneof_type~dyn,\n @index2~dyn^@index2.payload~dyn,\n @index3~dyn^@index3.oneof_type~dyn,\n @index4~dyn^@index4.payload~dyn,\n @index5~dyn^@index5.oneof_type~dyn,\n @index6~dyn^@index6.payload~dyn,\n @index7~dyn^@index7.single_bool~dyn,\n _||_(\n true~bool,\n @index8~dyn^@index8\n )~bool^logical_or,\n @index4~dyn^@index4.child~dyn,\n @index10~dyn^@index10.child~dyn,\n @index11~dyn^@index11.payload~dyn,\n @index12~dyn^@index12.single_bool~dyn\n ]~list(dyn),\n _||_(\n @index9~dyn^@index9,\n @index13~dyn^@index13\n )~bool^logical_or\n)~bool^cel_block_list", + type: "bool", + }, + { + original: { + name: "select_nested_message_map_index_1", + expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[1], cel.index(3) + cel.index(3), cel.index(4) + cel.index(3)], cel.index(5))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "15" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _+_(\n @index4~dyn^@index4,\n @index3~dyn^@index3\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "select_nested_message_map_index_2", + expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_int32_int64, cel.index(2)[0], cel.index(2)[1], cel.index(3) + cel.index(4), cel.index(2)[2], cel.index(5) + cel.index(6)], cel.index(7))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "8" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_int32_int64^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_int32_int64~dyn,\n _[_](\n @index2~dyn^@index2,\n 0~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _[_](\n @index2~dyn^@index2,\n 1~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _[_](\n @index2~dyn^@index2,\n 2~int\n )~dyn^index_list|index_map|optional_list_index_int|optional_map_index_value,\n _+_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64\n ]~list(dyn),\n @index7~dyn^@index7\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "ternary", + expr: "cel.block([msg.single_int64, cel.index(0) \u003e 0, cel.index(1) ? cel.index(0) : 0], cel.index(2))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "3" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _?_:_(\n @index1~dyn^@index1,\n @index0~dyn^@index0,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index2~dyn^@index2\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "nested_ternary", + expr: "cel.block([msg.single_int64, msg.single_int32, cel.index(0) \u003e 0, cel.index(1) \u003e 0, cel.index(0) + cel.index(1), cel.index(3) ? cel.index(4) : 0, cel.index(2) ? cel.index(5) : 0], cel.index(6))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "8" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int32~int,\n _\u003e_(\n @index0~dyn^@index0,\n 0~int\n )~bool^greater_int64,\n _\u003e_(\n @index1~dyn^@index1,\n 0~int\n )~bool^greater_int64,\n _+_(\n @index0~dyn^@index0,\n @index1~dyn^@index1\n )~dyn^add_bytes|add_double|add_duration_duration|add_duration_timestamp|add_int64|add_list|add_string|add_timestamp_duration|add_uint64,\n _?_:_(\n @index3~dyn^@index3,\n @index4~dyn^@index4,\n 0~int\n )~dyn^conditional,\n _?_:_(\n @index2~dyn^@index2,\n @index5~dyn^@index5,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index6~dyn^@index6\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "multiple_macros_1", + expr: "cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))", + value: { int64Value: "4" }, + }, + error: + "ERROR: multiple_macros_1:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_1:1:110: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), size([cel.index(0)]), [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1), size([cel.index(2)])], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .............................................................................................................^", + }, + { + original: { + name: "multiple_macros_2", + expr: "cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))", + value: { + listValue: { + values: [ + { boolValue: true }, + { boolValue: true }, + { boolValue: true }, + { boolValue: true }, + ], + }, + }, + }, + error: + "ERROR: multiple_macros_2:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .................................^\nERROR: multiple_macros_2:1:106: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0), [cel.index(0)], ['a'].exists(cel.iterVar(0, 1), cel.iterVar(0, 1) == 'a'), [cel.index(2)]], cel.index(1) + cel.index(1) + cel.index(3) + cel.index(3))\n | .........................................................................................................^", + }, + { + original: { + name: "multiple_macros_3", + expr: "cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))", + value: { boolValue: false }, + }, + error: + "ERROR: multiple_macros_3:1:34: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | .................................^\nERROR: multiple_macros_3:1:121: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ........................................................................................................................^\nERROR: multiple_macros_3:1:177: argument must be a simple name\n | cel.block([[1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 0)], cel.index(0) \u0026\u0026 cel.index(0) \u0026\u0026 [1].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1) \u0026\u0026 [2].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) \u003e 1))\n | ................................................................................................................................................................................^", + }, + { + original: { + name: "nested_macros_1", + expr: "cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))", + value: { + listValue: { + values: [ + { + listValue: { + values: [ + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + { + listValue: { + values: [ + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + { + listValue: { + values: [ + { int64Value: "2" }, + { int64Value: "3" }, + { int64Value: "4" }, + ], + }, + }, + ], + }, + }, + }, + error: + "ERROR: nested_macros_1:1:52: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | ...................................................^\nERROR: nested_macros_1:1:88: argument is not an identifier\n | cel.block([[1, 2, 3]], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1)))\n | .......................................................................................^", + }, + { + original: { + name: "nested_macros_2", + expr: "[1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))", + value: { + listValue: { + values: [ + { listValue: { values: [{ int64Value: "1" }] } }, + { listValue: { values: [{ int64Value: "2" }] } }, + ], + }, + }, + }, + error: + "ERROR: nested_macros_2:1:23: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ......................^\nERROR: nested_macros_2:1:59: argument is not an identifier\n | [1, 2].map(cel.iterVar(0, 0), [1, 2, 3].filter(cel.iterVar(1, 0), cel.iterVar(1, 0) == cel.iterVar(0, 0)))\n | ..........................................................^", + }, + { + original: { + name: "adjacent_macros", + expr: "cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))", + value: { boolValue: true }, + }, + error: + "ERROR: adjacent_macros:1:51: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ..................................................^\nERROR: adjacent_macros:1:87: argument is not an identifier\n | cel.block([[1, 2, 3], cel.index(0).map(cel.iterVar(0, 0), cel.index(0).map(cel.iterVar(1, 0), cel.iterVar(1, 0) + 1))], cel.index(1) == cel.index(1))\n | ......................................................................................^", + }, + { + original: { + name: "macro_shadowed_variable_1", + expr: "cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))", + typeEnv: [ + { name: "x", ident: { type: { primitive: "INT64" } } }, + ], + bindings: { x: { value: { int64Value: "5" } } }, + value: { boolValue: true }, + }, + error: + "ERROR: macro_shadowed_variable_1:1:90: argument must be a simple name\n | cel.block([x - 1, cel.index(0) \u003e 3], [cel.index(1) ? cel.index(0) : 5].exists(cel.iterVar(0, 0), cel.iterVar(0, 0) - 1 \u003e 3) || cel.index(1))\n | .........................................................................................^", + }, + { + original: { + name: "macro_shadowed_variable_2", + expr: "['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])", + typeEnv: [ + { name: "x", ident: { type: { primitive: "INT64" } } }, + ], + bindings: { x: { value: { int64Value: "5" } } }, + value: { + listValue: { + values: [ + { + listValue: { + values: [ + { + listValue: { + values: [ + { stringValue: "foofoo" }, + { stringValue: "foofoo" }, + { stringValue: "foofoo" }, + { stringValue: "foofoo" }, + ], + }, + }, + { + listValue: { + values: [ + { stringValue: "foofoo" }, + { stringValue: "foofoo" }, + { stringValue: "foofoo" }, + { stringValue: "foofoo" }, + ], + }, + }, + ], + }, + }, + { + listValue: { + values: [ + { + listValue: { + values: [ + { stringValue: "barbar" }, + { stringValue: "barbar" }, + { stringValue: "barbar" }, + { stringValue: "barbar" }, + ], + }, + }, + { + listValue: { + values: [ + { stringValue: "barbar" }, + { stringValue: "barbar" }, + { stringValue: "barbar" }, + { stringValue: "barbar" }, + ], + }, + }, + ], + }, + }, + ], + }, + }, + }, + error: + "ERROR: macro_shadowed_variable_2:1:31: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | ..............................^\nERROR: macro_shadowed_variable_2:1:134: argument is not an identifier\n | ['foo', 'bar'].map(cel.iterVar(1, 0), [cel.iterVar(1, 0) + cel.iterVar(1, 0), cel.iterVar(1, 0) + cel.iterVar(1, 0)]).map(cel.iterVar(0, 0), [cel.iterVar(0, 0) + cel.iterVar(0, 0), cel.iterVar(0, 0) + cel.iterVar(0, 0)])\n | .....................................................................................................................................^", + }, + { + original: { + name: "inclusion_list", + expr: "cel.block([[1, 2, 3], 1 in cel.index(0), 2 in cel.index(0), cel.index(1) \u0026\u0026 cel.index(2), [3, cel.index(0)], 3 in cel.index(4), cel.index(5) \u0026\u0026 cel.index(1)], cel.index(3) \u0026\u0026 cel.index(6))", + value: { boolValue: true }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 3^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n @in(\n 1~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n @in(\n 2~int,\n @index0~dyn^@index0\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and,\n [\n 3~int,\n @index0~dyn^@index0\n ]~list(dyn),\n @in(\n 3~int,\n @index4~dyn^@index4\n )~bool^in_list|in_map,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index1~dyn^@index1\n )~bool^logical_and\n ]~list(dyn),\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index6~dyn^@index6\n )~bool^logical_and\n)~bool^cel_block_list", + type: "bool", + }, + { + original: { + name: "inclusion_map", + expr: 'cel.block([{true: false}, {"a": 1, 2: cel.index(0), 3: cel.index(0)}], 2 in cel.index(1))', + value: { boolValue: true }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n true^#*expr.Constant_BoolValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#,\n @in(\n 2^#*expr.Constant_Int64Value#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n {\n true~bool:false~bool\n }~map(bool, bool),\n {\n "a"~string:1~int,\n 2~int:@index0~dyn^@index0,\n 3~int:@index0~dyn^@index0\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn)),\n @in(\n 2~int,\n @index1~dyn^@index1\n )~bool^in_list|in_map\n)~bool^cel_block_list', + type: "bool", + }, + { + original: { + name: "presence_test", + expr: 'cel.block([{"a": true}, has(cel.index(0).a), cel.index(0)["a"]], cel.index(1) \u0026\u0026 cel.index(2))', + value: { boolValue: true }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "a"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#,\n _[_](\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "a"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n {\n "a"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool,\n _[_](\n @index0~dyn^@index0,\n "a"~string\n )~dyn^index_map|optional_map_index_value\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index2~dyn^@index2\n )~bool^logical_and\n)~bool^cel_block_list', + type: "bool", + }, + { + original: { + name: "presence_test_2", + expr: 'cel.block([{"a": true}, has(cel.index(0).a)], cel.index(1) \u0026\u0026 cel.index(1))', + value: { boolValue: true }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n {\n "a"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.a~test-only~^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n {\n "a"~string:true~bool\n }~map(string, bool),\n @index0~dyn^@index0.a~test-only~~bool\n ]~list(dyn),\n _\u0026\u0026_(\n @index1~dyn^@index1,\n @index1~dyn^@index1\n )~bool^logical_and\n)~bool^cel_block_list', + type: "bool", + }, + { + original: { + name: "presence_test_with_ternary", + expr: "cel.block([msg.oneof_type, has(cel.index(0).payload), cel.index(0).payload, cel.index(2).single_int64, cel.index(1) ? cel.index(3) : 0], cel.index(4))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "10" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~test-only~~bool,\n @index0~dyn^@index0.payload~dyn,\n @index2~dyn^@index2.single_int64~dyn,\n _?_:_(\n @index1~dyn^@index1,\n @index3~dyn^@index3,\n 0~int\n )~dyn^conditional\n ]~list(dyn),\n @index4~dyn^@index4\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "presence_test_with_ternary_2", + expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(0).payload), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "10" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index0~dyn^@index0.payload~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "presence_test_with_ternary_3", + expr: "cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).single_int64, has(cel.index(1).single_int64), cel.index(2) * 0, cel.index(3) ? cel.index(2) : cel.index(4)], cel.index(5))", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { int64Value: "10" }, + }, + ast: "cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _*_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.single_int64~dyn,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _*_(\n @index2~dyn^@index2,\n 0~int\n )~int^multiply_int64,\n _?_:_(\n @index3~dyn^@index3,\n @index2~dyn^@index2,\n @index4~dyn^@index4\n )~dyn^conditional\n ]~list(dyn),\n @index5~dyn^@index5\n)~dyn^cel_block_list", + type: "dyn", + }, + { + original: { + name: "presence_test_with_ternary_nested", + expr: 'cel.block([msg.oneof_type, cel.index(0).payload, cel.index(1).map_string_string, has(msg.oneof_type), has(cel.index(0).payload), cel.index(3) \u0026\u0026 cel.index(4), has(cel.index(1).single_int64), cel.index(5) \u0026\u0026 cel.index(6), has(cel.index(1).map_string_string), has(cel.index(2).key), cel.index(8) \u0026\u0026 cel.index(9), cel.index(2).key, cel.index(11) == "A", cel.index(10) ? cel.index(12) : false], cel.index(7) ? cel.index(13) : false)', + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 5, + singleInt64: "3", + oneofType: { + payload: { + singleInt32: 8, + singleInt64: "10", + mapInt32Int64: { "0": "1", "1": "5", "2": "2" }, + mapStringString: { key: "A" }, + }, + }, + }, + }, + }, + }, + value: { boolValue: true }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n msg^#*expr.Expr_IdentExpr#.oneof_type^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.oneof_type~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.payload~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.single_int64~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key~test-only~^#*expr.Expr_SelectExpr#,\n _\u0026\u0026_(\n cel^#*expr.Expr_IdentExpr#.index(\n 8^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 9^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.key^#*expr.Expr_SelectExpr#,\n _==_(\n cel^#*expr.Expr_IdentExpr#.index(\n 11^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "A"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 12^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n _?_:_(\n cel^#*expr.Expr_IdentExpr#.index(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 13^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~cel.expr.conformance.proto3.NestedTestAllTypes,\n @index0~dyn^@index0.payload~dyn,\n @index1~dyn^@index1.map_string_string~dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.oneof_type~test-only~~bool,\n @index0~dyn^@index0.payload~test-only~~bool,\n _\u0026\u0026_(\n @index3~dyn^@index3,\n @index4~dyn^@index4\n )~bool^logical_and,\n @index1~dyn^@index1.single_int64~test-only~~bool,\n _\u0026\u0026_(\n @index5~dyn^@index5,\n @index6~dyn^@index6\n )~bool^logical_and,\n @index1~dyn^@index1.map_string_string~test-only~~bool,\n @index2~dyn^@index2.key~test-only~~bool,\n _\u0026\u0026_(\n @index8~dyn^@index8,\n @index9~dyn^@index9\n )~bool^logical_and,\n @index2~dyn^@index2.key~dyn,\n _==_(\n @index11~dyn^@index11,\n "A"~string\n )~bool^equals,\n _?_:_(\n @index10~dyn^@index10,\n @index12~dyn^@index12,\n false~bool\n )~dyn^conditional\n ]~list(dyn),\n _?_:_(\n @index7~dyn^@index7,\n @index13~dyn^@index13,\n false~bool\n )~dyn^conditional\n)~dyn^cel_block_list', + type: "dyn", + }, + { + original: { + name: "optional_list", + expr: "cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))", + typeEnv: [ + { name: "opt_x", ident: { type: { primitive: "INT64" } } }, + ], + bindings: { opt_x: { value: { int64Value: "5" } } }, + value: { boolValue: true }, + }, + error: + "ERROR: optional_list:1:30: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | .............................^\nERROR: optional_list:1:45: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................^\nERROR: optional_list:1:77: unsupported syntax '?'\n | cel.block([optional.none(), [?cel.index(0), ?optional.of(opt_x)], [5], [10, ?cel.index(0), cel.index(1), cel.index(1)], [10, cel.index(2), cel.index(2)]], cel.index(3) == cel.index(4))\n | ............................................................................^", + }, + { + original: { + name: "optional_map", + expr: 'cel.block([optional.of("hello"), {?"hello": cel.index(0)}, cel.index(1)["hello"], cel.index(2) + cel.index(2)], cel.index(3) == "hellohello")', + value: { boolValue: true }, + }, + error: + 'ERROR: optional_map:1:35: unsupported syntax \'?\'\n | cel.block([optional.of("hello"), {?"hello": cel.index(0)}, cel.index(1)["hello"], cel.index(2) + cel.index(2)], cel.index(3) == "hellohello")\n | ..................................^', + }, + { + original: { + name: "optional_map_chained", + expr: 'cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))', + value: { stringValue: "test" }, + }, + error: + 'ERROR: optional_map_chained:1:51: unsupported syntax \'?\'\n | cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | ..................................................^\nERROR: optional_map_chained:1:86: unsupported syntax \'[?\'\n | cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .....................................................................................^\nERROR: optional_map_chained:1:110: unsupported syntax \'[?\'\n | cel.block([{"key": "test"}, optional.of("test"), {?"key": cel.index(1)}, cel.index(2)[?"bogus"], cel.index(0)[?"bogus"], cel.index(3).or(cel.index(4)), cel.index(0)["key"], cel.index(5).orValue(cel.index(6))], cel.index(7))\n | .............................................................................................................^', + }, + { + original: { + name: "optional_message", + expr: "cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))", + container: "cel.expr.conformance.proto3", + value: { int64Value: "5" }, + }, + error: + "ERROR: optional_message:1:69: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | ....................................................................^\nERROR: optional_message:1:98: unsupported syntax '?'\n | cel.block([optional.ofNonZeroValue(1), optional.of(4), TestAllTypes{?single_int64: cel.index(0), ?single_int32: cel.index(1)}, cel.index(2).single_int32, cel.index(2).single_int64, cel.index(3) + cel.index(4)], cel.index(5))\n | .................................................................................................^", + }, + { + original: { + name: "call", + expr: 'cel.block(["h" + "e", cel.index(0) + "l", cel.index(1) + "l", cel.index(2) + "o", cel.index(3) + " world"], cel.index(4).matches(cel.index(3)))', + value: { boolValue: true }, + }, + ast: 'cel^#*expr.Expr_IdentExpr#.block(\n [\n _+_(\n "h"^#*expr.Constant_StringValue#,\n "e"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "l"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "l"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "o"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n " world"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n cel^#*expr.Expr_IdentExpr#.index(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.matches(\n cel^#*expr.Expr_IdentExpr#.index(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'cel.@block(\n [\n _+_(\n "h"~string,\n "e"~string\n )~string^add_string,\n _+_(\n @index0~dyn^@index0,\n "l"~string\n )~string^add_string,\n _+_(\n @index1~dyn^@index1,\n "l"~string\n )~string^add_string,\n _+_(\n @index2~dyn^@index2,\n "o"~string\n )~string^add_string,\n _+_(\n @index3~dyn^@index3,\n " world"~string\n )~string^add_string\n ]~list(string),\n @index4~dyn^@index4.matches(\n @index3~dyn^@index3\n )~bool^matches_string\n)~bool^cel_block_list', + type: "bool", + }, + ], + }, + ], + }, + { + name: "comparisons", + suites: [ + { + name: "eq_literal", + tests: [ + { + original: { + name: "eq_int", + expr: "1 == 1", + value: { boolValue: true }, + }, + ast: "_==_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n 1~int,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_int", + expr: "-1 == 1", + value: { boolValue: false }, + }, + ast: "_==_(\n -1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n -1~int,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int_uint", + expr: "dyn(1) == 1u", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_int_uint", + expr: "dyn(2) == 1u", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int_double", + expr: "dyn(1) == 1.0", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_int_double", + expr: "dyn(2) == 1.0", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint", + expr: "2u == 2u", + value: { boolValue: true }, + }, + ast: "_==_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n 2u~uint,\n 2u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_uint", + expr: "1u == 2u", + value: { boolValue: false }, + }, + ast: "_==_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n 1u~uint,\n 2u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint_int", + expr: "dyn(1u) == 1", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_uint_int", + expr: "dyn(2u) == 1", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint_double", + expr: "dyn(1u) == 1.0", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_uint_double", + expr: "dyn(2u) == 1.0", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double", + expr: "1.0 == 1.0e+0", + value: { boolValue: true }, + }, + ast: "_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n 1~double,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_double", + expr: "-1.0 == 1.0", + value: { boolValue: false }, + }, + ast: "_==_(\n -1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n -1~double,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_double_nan", + expr: "0.0/0.0 == 0.0/0.0", + value: { boolValue: false }, + }, + ast: "_==_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_int_double_nan", + expr: "dyn(1) == 0.0/0.0", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_uint_double_nan", + expr: "dyn(1u) == 0.0/0.0", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double_int", + expr: "dyn(1.0) == 1", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_double_int", + expr: "dyn(2.0) == 1", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double_uint", + expr: "dyn(1.0) == 1u", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_double_uint", + expr: "dyn(2.0) == 1u", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_string", + expr: "'' == \"\"", + value: { boolValue: true }, + }, + ast: '_==_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: '_==_(\n ""~string,\n ""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_string", + expr: "'a' == 'b'", + value: { boolValue: false }, + }, + ast: '_==_(\n "a"^#*expr.Constant_StringValue#,\n "b"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: '_==_(\n "a"~string,\n "b"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_raw_string", + expr: "'abc' == r'abc'", + value: { boolValue: true }, + }, + ast: '_==_(\n "abc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "abc"~string,\n "abc"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_string_case", + expr: "'abc' == 'ABC'", + value: { boolValue: false }, + }, + ast: '_==_(\n "abc"^#*expr.Constant_StringValue#,\n "ABC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "abc"~string,\n "ABC"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_string_unicode", + expr: "'ίσος' == 'ίσος'", + value: { boolValue: true }, + }, + ast: '_==_(\n "ίσος"^#*expr.Constant_StringValue#,\n "ίσος"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ίσος"~string,\n "ίσος"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_string_unicode_ascii", + expr: "'a' == 'à'", + value: { boolValue: false }, + }, + ast: '_==_(\n "a"^#*expr.Constant_StringValue#,\n "à"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: '_==_(\n "a"~string,\n "à"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "no_string_normalization", + description: "Should not normalize Unicode.", + expr: "'Am\\u00E9lie' == 'Ame\\u0301lie'", + value: { boolValue: false }, + }, + ast: '_==_(\n "Amélie"^#*expr.Constant_StringValue#,\n "Amélie"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "Amélie"~string,\n "Amélie"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_null", + expr: "null == null", + value: { boolValue: true }, + }, + ast: "_==_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n null~null,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bool", + expr: "true == true", + value: { boolValue: true }, + }, + ast: "_==_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n true~bool,\n true~bool\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_bool", + expr: "false == true", + value: { boolValue: false }, + }, + ast: "_==_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n false~bool,\n true~bool\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bytes", + description: "Test bytes literal equality with encoding", + expr: "b'ÿ' == b'\\303\\277'", + value: { boolValue: true }, + }, + ast: '_==_(\n b"ÿ"^#*expr.Constant_BytesValue#,\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: '_==_(\n b"ÿ"~bytes,\n b"ÿ"~bytes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_bytes", + expr: "b'abc' == b'abcd'", + value: { boolValue: false }, + }, + ast: '_==_(\n b"abc"^#*expr.Constant_BytesValue#,\n b"abcd"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n b"abc"~bytes,\n b"abcd"~bytes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_list_empty", + expr: "[] == []", + value: { boolValue: true }, + }, + ast: "_==_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n []~list(dyn),\n []~list(dyn)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_list_null", + expr: "[null] == [null]", + value: { boolValue: true }, + }, + ast: "_==_(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n null~null\n ]~list(null),\n [\n null~null\n ]~list(null)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_list_null", + expr: "['1', '2', null] == ['1', '2', '3']", + value: { boolValue: false }, + }, + ast: '_==_(\n [\n "1"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n "1"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#,\n "3"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n [\n "1"~string,\n "2"~string,\n null~null\n ]~list(dyn),\n [\n "1"~string,\n "2"~string,\n "3"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_list_numbers", + expr: "[1, 2, 3] == [1, 2, 3]", + value: { boolValue: true }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_list_mixed_type_numbers", + expr: "[1.0, 2.0, 3] == [1u, 2, 3u]", + value: { boolValue: true }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n 1~double,\n 2~double,\n 3~int\n ]~list(dyn),\n [\n 1u~uint,\n 2~int,\n 3u~uint\n ]~list(dyn)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_list_mixed_type_numbers", + expr: "[1.0, 2.1] == [1u, 2]", + value: { boolValue: false }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_DoubleValue#,\n 2.1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n 1~double,\n 2.1~double\n ]~list(double),\n [\n 1u~uint,\n 2~int\n ]~list(dyn)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_list_order", + expr: "[1, 2, 3] == [1, 3, 2]", + value: { boolValue: false }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n [\n 1~int,\n 3~int,\n 2~int\n ]~list(int)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_list_string_case", + expr: "['case'] == ['cAse']", + value: { boolValue: false }, + }, + ast: '_==_(\n [\n "case"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n "cAse"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n [\n "case"~string\n ]~list(string),\n [\n "cAse"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_list_length", + expr: "['one'] == [2, 3]", + disableCheck: true, + value: { boolValue: false }, + }, + ast: '_==_(\n [\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_==_' applied to '(list(string), list(int))'\n | ['one'] == [2, 3]\n | ........^", + }, + { + original: { + name: "not_eq_list_false_vs_types", + expr: "[1, 'dos', 3] == [1, 2, 4]", + value: { boolValue: false }, + }, + ast: '_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n "dos"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n [\n 1~int,\n "dos"~string,\n 3~int\n ]~list(dyn),\n [\n 1~int,\n 2~int,\n 4~int\n ]~list(int)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_map_empty", + expr: "{} == {}", + value: { boolValue: true }, + }, + ast: "_==_(\n {}^#*expr.Expr_StructExpr#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n {}~map(dyn, dyn),\n {}~map(dyn, dyn)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_map_null", + expr: "{'k': null} == {'k': null}", + value: { boolValue: true }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:null~null\n }~map(string, null),\n {\n "k"~string:null~null\n }~map(string, null)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_map_null", + expr: "{'k': 1, 'j': 2} == {'k': 1, 'j': null}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "j"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "j"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:1~int,\n "j"~string:2~int\n }~map(string, int),\n {\n "k"~string:1~int,\n "j"~string:null~null\n }~map(string, dyn)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_map_onekey", + expr: "{'k':'v'} == {\"k\":\"v\"}", + value: { boolValue: true }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:"v"~string\n }~map(string, string),\n {\n "k"~string:"v"~string\n }~map(string, string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_map_double_value", + expr: "{'k':1.0} == {'k':1e+0}", + value: { boolValue: true }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:1~double\n }~map(string, double),\n {\n "k"~string:1~double\n }~map(string, double)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_map_mixed_type_numbers", + expr: "{1: 1.0, 2u: 3u} == {1u: 1, 2: 3.0}", + value: { boolValue: true }, + }, + ast: "_==_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n {\n 1~int:1~double,\n 2u~uint:3u~uint\n }~map(dyn, dyn),\n {\n 1u~uint:1~int,\n 2~int:3~double\n }~map(dyn, dyn)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_map_value", + expr: "{'k':'v'} == {'k':'v1'}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:"v"~string\n }~map(string, string),\n {\n "k"~string:"v1"~string\n }~map(string, string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_map_extra_key", + expr: "{'k':'v','k1':'v1'} == {'k':'v'}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:"v"~string,\n "k1"~string:"v1"~string\n }~map(string, string),\n {\n "k"~string:"v"~string\n }~map(string, string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_map_key_order", + expr: "{'k1':'v1','k2':'v2'} == {'k2':'v2','k1':'v1'}", + value: { boolValue: true }, + }, + ast: '_==_(\n {\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k2"^#*expr.Constant_StringValue#:"v2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k2"^#*expr.Constant_StringValue#:"v2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k1"~string:"v1"~string,\n "k2"~string:"v2"~string\n }~map(string, string),\n {\n "k2"~string:"v2"~string,\n "k1"~string:"v1"~string\n }~map(string, string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_map_key_casing", + expr: "{'key':'value'} == {'Key':'value'}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n "key"^#*expr.Constant_StringValue#:"value"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "Key"^#*expr.Constant_StringValue#:"value"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "key"~string:"value"~string\n }~map(string, string),\n {\n "Key"~string:"value"~string\n }~map(string, string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_map_false_vs_types", + expr: "{'k1': 1, 'k2': 'dos', 'k3': 3} == {'k1': 1, 'k2': 2, 'k3': 4}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n "k1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "k2"^#*expr.Constant_StringValue#:"dos"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k3"^#*expr.Constant_StringValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "k2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "k3"^#*expr.Constant_StringValue#:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k1"~string:1~int,\n "k2"~string:"dos"~string,\n "k3"~string:3~int\n }~map(string, dyn),\n {\n "k1"~string:1~int,\n "k2"~string:2~int,\n "k3"~string:4~int\n }~map(string, int)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_mixed_types", + expr: "1.0 == 1", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_==_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(double, int)'\n | 1.0 == 1\n | ....^", + }, + { + original: { + name: "eq_list_elem_mixed_types", + expr: "[1] == [1.0]", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_==_' applied to '(list(int), list(double))'\n | [1] == [1.0]\n | ....^", + }, + { + original: { + name: "eq_map_value_mixed_types", + expr: "{'k':'v', 1:1} == {'k':'v', 1:'v1'}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n "k"~string:"v"~string,\n 1~int:1~int\n }~map(dyn, dyn),\n {\n "k"~string:"v"~string,\n 1~int:"v1"~string\n }~map(dyn, string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_dyn_json_null", + expr: "dyn(google.protobuf.Value{}) == null", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n google.protobuf.Value{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n google.protobuf.Value{}~dyn^google.protobuf.Value\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_bool_null", + expr: "dyn(false) == null", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n false~bool\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_bytes_null", + expr: "dyn(b'') == null", + value: { boolValue: false }, + }, + ast: '_==_(\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n dyn(\n b""~bytes\n )~dyn^to_dyn,\n null~null\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_dyn_double_null", + expr: "dyn(2.1) == null", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 2.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 2.1~double\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_duration_null", + expr: "dyn(duration('0s')) == null", + value: { boolValue: false }, + }, + ast: '_==_(\n dyn(\n duration(\n "0s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n dyn(\n duration(\n "0s"~string\n )~duration^string_to_duration\n )~dyn^to_dyn,\n null~null\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_dyn_int_null", + expr: "dyn(1) == null", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_list_null", + expr: "dyn([]) == null", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_map_null", + expr: "dyn({}) == null", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n {}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n {}~map(dyn, dyn)\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_proto2_msg_null", + expr: "dyn(TestAllTypes{}) == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_proto3_msg_null", + expr: "dyn(TestAllTypes{}) == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_string_null", + expr: "dyn('') == null", + value: { boolValue: false }, + }, + ast: '_==_(\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n dyn(\n ""~string\n )~dyn^to_dyn,\n null~null\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "not_eq_dyn_timestamp_null", + expr: "dyn(timestamp(0)) == null", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n timestamp(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n timestamp(\n 0~int\n )~timestamp^int64_to_timestamp\n )~dyn^to_dyn,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_list_elem_null", + expr: "[1, 2, null] == [1, null, 3]", + value: { boolValue: false }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#,\n null^#*expr.Constant_NullValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n 1~int,\n 2~int,\n null~null\n ]~list(dyn),\n [\n 1~int,\n null~null,\n 3~int\n ]~list(dyn)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_map_value_null", + expr: "{1:'hello', 2:'world'} == {1:'goodbye', 2:null}", + value: { boolValue: false }, + }, + ast: '_==_(\n {\n 1^#*expr.Constant_Int64Value#:"hello"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:"world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n {\n 1~int:"hello"~string,\n 2~int:"world"~string\n }~map(int, string),\n {\n 1~int:"goodbye"~string,\n 2~int:null~null\n }~map(int, dyn)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_dyn_int_uint", + expr: "dyn(1) == 1u", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_dyn_int_double", + expr: "dyn(1) == 1.0", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_dyn_uint_int", + expr: "dyn(1u) == 1", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_dyn_uint_double", + expr: "dyn(1u) == 1.0", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_dyn_double_int", + expr: "dyn(1.0) == 1", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_dyn_double_uint", + expr: "dyn(1.0) == 1u", + value: { boolValue: true }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_int_uint", + expr: "dyn(1) == 2u", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_int_double", + expr: "dyn(1) == 2.0", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_uint_int", + expr: "dyn(1u) == 2", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_uint_double", + expr: "dyn(1u) == 120", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 120^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 120~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_double_int", + expr: "dyn(1.0) == 2", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_eq_dyn_double_uint", + expr: "dyn(1.0) == 2u", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "eq_wrapper", + tests: [ + { + original: { + name: "eq_bool", + expr: "google.protobuf.BoolValue{value: true} == true", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue,\n true~bool\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bool_empty", + expr: "google.protobuf.BoolValue{} == false", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n false~bool\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bool_not_null", + expr: "google.protobuf.BoolValue{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_bool_proto2_null", + expr: "TestAllTypes{}.single_bool_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bool_proto3_null", + expr: "TestAllTypes{}.single_bool_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bool_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bool_wrapper~wrapper(bool),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bytes", + expr: "google.protobuf.BytesValue{value: b'set'} == b'set'", + value: { boolValue: true }, + }, + ast: '_==_(\n google.protobuf.BytesValue{\n value:b"set"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n b"set"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n google.protobuf.BytesValue{\n value:b"set"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue,\n b"set"~bytes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_bytes_empty", + expr: "google.protobuf.BytesValue{} == b''", + value: { boolValue: true }, + }, + ast: '_==_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n b""~bytes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_bytes_not_null", + expr: "google.protobuf.BytesValue{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_bytes_proto2_null", + expr: "TestAllTypes{}.single_bytes_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_bytes_proto3_null", + expr: "TestAllTypes{}.single_bytes_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_bytes_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_bytes_wrapper~wrapper(bytes),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double", + expr: "google.protobuf.DoubleValue{value: -1.175494e-40} == -1.175494e-40", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.175494e-40^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.DoubleValue{\n value:-1.175494e-40~double\n }~wrapper(double)^google.protobuf.DoubleValue,\n -1.175494e-40~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double_empty", + expr: "google.protobuf.DoubleValue{} == 0.0", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n 0~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double_not_null", + expr: "google.protobuf.DoubleValue{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_double_proto2_null", + expr: "TestAllTypes{}.single_double_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_double_proto3_null", + expr: "TestAllTypes{}.single_double_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_float", + expr: "google.protobuf.FloatValue{value: -1.5} == -1.5", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.FloatValue{\n value:-1.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{\n value:-1.5~double\n }~wrapper(double)^google.protobuf.FloatValue,\n -1.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_float_empty", + expr: "google.protobuf.FloatValue{} == 0.0", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n 0~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_float_not_null", + expr: "google.protobuf.FloatValue{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_float_proto2_null", + expr: "TestAllTypes{}.single_float_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_float_proto3_null", + expr: "TestAllTypes{}.single_float_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int32", + expr: "google.protobuf.Int32Value{value: 123} == 123", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.Int32Value{\n value:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int32Value{\n value:123~int\n }~wrapper(int)^google.protobuf.Int32Value,\n 123~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int32_empty", + expr: "google.protobuf.Int32Value{} == 0", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n 0~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int32_not_null", + expr: "google.protobuf.Int32Value{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_int32_proto2_null", + expr: "TestAllTypes{}.single_int32_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int32_proto3_null", + expr: "TestAllTypes{}.single_int32_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int64", + expr: "google.protobuf.Int64Value{value: 2147483650} == 2147483650", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.Int64Value{\n value:2147483650^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2147483650^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int64Value{\n value:2147483650~int\n }~wrapper(int)^google.protobuf.Int64Value,\n 2147483650~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int64_empty", + expr: "google.protobuf.Int64Value{} == 0", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n 0~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int64_not_null", + expr: "google.protobuf.Int64Value{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_int64_proto2_null", + expr: "TestAllTypes{}.single_int64_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_int64_proto3_null", + expr: "TestAllTypes{}.single_int64_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_string", + expr: "google.protobuf.StringValue{value: 'set'} == 'set'", + value: { boolValue: true }, + }, + ast: '_==_(\n google.protobuf.StringValue{\n value:"set"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "set"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n google.protobuf.StringValue{\n value:"set"~string\n }~wrapper(string)^google.protobuf.StringValue,\n "set"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_string_empty", + expr: "google.protobuf.StringValue{} == ''", + value: { boolValue: true }, + }, + ast: '_==_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n ""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_string_not_null", + expr: "google.protobuf.StringValue{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.StringValue{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_string_proto2_null", + expr: "TestAllTypes{}.single_string_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_string_proto3_null", + expr: "TestAllTypes{}.single_string_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_string_wrapper~wrapper(string),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint32", + expr: "google.protobuf.UInt32Value{value: 42u} == 42u", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.UInt32Value{\n value:42u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt32Value{\n value:42u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n 42u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint32_empty", + expr: "google.protobuf.UInt32Value{} == 0u", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n 0u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint32_not_null", + expr: "google.protobuf.UInt32Value{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_uint32_proto2_null", + expr: "TestAllTypes{}.single_uint32_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint32_proto3_null", + expr: "TestAllTypes{}.single_uint32_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint32_wrapper~wrapper(uint),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint64", + expr: "google.protobuf.UInt64Value{value: 4294967296u} == 4294967296u", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.UInt64Value{\n value:4294967296u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 4294967296u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt64Value{\n value:4294967296u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value,\n 4294967296u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint64_empty", + expr: "google.protobuf.UInt64Value{} == 0u", + value: { boolValue: true }, + }, + ast: "_==_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n 0u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint64_not_null", + expr: "google.protobuf.UInt64Value{} != null", + value: { boolValue: true }, + }, + ast: "_!=_(\n google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "eq_uint64_proto2_null", + expr: "TestAllTypes{}.single_uint64_wrapper == null", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_uint64_proto3_null", + expr: "TestAllTypes{}.single_uint64_wrapper == null", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_uint64_wrapper~wrapper(uint),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_proto2", + expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto3", + expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} == TestAllTypes{single_int64: 1234, single_string: '1234'}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto2_missing_fields_neq", + expr: "TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto3_missing_fields_neq", + expr: "TestAllTypes{single_int64: 1234} == TestAllTypes{single_string: '1234'}", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto_nan_equal", + description: + "For proto equality, fields with NaN value are treated as not equal.", + expr: "TestAllTypes{single_double: double('NaN')} == TestAllTypes{single_double: double('NaN')}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto_different_types", + description: + "At runtime, differently typed messages are treated as not equal.", + expr: "dyn(TestAllTypes{}) == dyn(NestedTestAllTypes{})", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "_==_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "eq_proto2_any_unpack_equal", + description: "Any values should be unpacked and compared.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto2_any_unpack_not_equal", + description: "Any values should be unpacked and compared.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto2_any_unpack_bytewise_fallback_not_equal", + description: + "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto2_any_unpack_bytewise_fallback_equal", + description: + "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto3_any_unpack_equal", + description: "Any values should be unpacked and compared.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto3_any_unpack_not_equal", + description: "Any values should be unpacked and compared.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'a\\000\\000\\000\\000\\000H\\223\\300r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"a\\x00\\x00\\x00\\x00\\x00H\\x93\\xc0r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto3_any_unpack_bytewise_fallback_not_equal", + description: + "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_proto3_any_unpack_bytewise_fallback_equal", + description: + "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} == TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: '_==_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "ne_literal", + tests: [ + { + original: { + name: "ne_int", + expr: "24 != 42", + value: { boolValue: true }, + }, + ast: "_!=_(\n 24^#*expr.Constant_Int64Value#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n 24~int,\n 42~int\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_int", + expr: "1 != 1", + value: { boolValue: false }, + }, + ast: "_!=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n 1~int,\n 1~int\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_int_double", + expr: "dyn(24) != 24.1", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 24.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 24.1~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_int_double", + expr: "dyn(1) != 1.0", + value: { boolValue: false }, + }, + ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_int_uint", + expr: "dyn(24) != 42u", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 24^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 24~int\n )~dyn^to_dyn,\n 42u~uint\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_int_uint", + expr: "dyn(1) != 1u", + value: { boolValue: false }, + }, + ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_uint", + expr: "1u != 2u", + value: { boolValue: true }, + }, + ast: "_!=_(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n 1u~uint,\n 2u~uint\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_uint", + expr: "99u != 99u", + value: { boolValue: false }, + }, + ast: "_!=_(\n 99u^#*expr.Constant_Uint64Value#,\n 99u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n 99u~uint,\n 99u~uint\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_uint_double", + expr: "dyn(1u) != 2.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_uint_double", + expr: "dyn(99u) != 99.0", + value: { boolValue: false }, + }, + ast: "_!=_(\n dyn(\n 99u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 99u~uint\n )~dyn^to_dyn,\n 99~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_double", + expr: "9.0e+3 != 9001.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n 9000^#*expr.Constant_DoubleValue#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n 9000~double,\n 9001~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_double_nan", + expr: "0.0/0.0 != 0.0/0.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_int_double_nan", + expr: "dyn(1) != 0.0/0.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_uint_double_nan", + expr: "dyn(1u) != 0.0/0.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_double", + expr: "1.0 != 1e+0", + value: { boolValue: false }, + }, + ast: "_!=_(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n 1~double,\n 1~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_double_int", + expr: "dyn(9000) != 9001.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 9000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 9000~int\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_double_int", + expr: "dyn(1) != 1e+0", + value: { boolValue: false }, + }, + ast: "_!=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_double_uint", + expr: "dyn(9000u) != 9001.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n 9000u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 9001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 9000u~uint\n )~dyn^to_dyn,\n 9001~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_double_uint", + expr: "dyn(1u) != 1e+0", + value: { boolValue: false }, + }, + ast: "_!=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_double_nan", + expr: "0.0/0.0 != 0.0/0.0", + value: { boolValue: true }, + }, + ast: "_!=_(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double,\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_string", + expr: "'abc' != ''", + value: { boolValue: true }, + }, + ast: '_!=_(\n "abc"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n "abc"~string,\n ""~string\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "not_ne_string", + expr: "'abc' != 'abc'", + value: { boolValue: false }, + }, + ast: '_!=_(\n "abc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n "abc"~string,\n "abc"~string\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_string_unicode", + expr: "'résumé' != 'resume'", + value: { boolValue: true }, + }, + ast: '_!=_(\n "résumé"^#*expr.Constant_StringValue#,\n "resume"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n "résumé"~string,\n "resume"~string\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "not_ne_string_unicode", + expr: "'ίδιο' != 'ίδιο'", + value: { boolValue: false }, + }, + ast: '_!=_(\n "ίδιο"^#*expr.Constant_StringValue#,\n "ίδιο"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n "ίδιο"~string,\n "ίδιο"~string\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_bytes", + expr: "b'\\x00\\xFF' != b'ÿ'", + value: { boolValue: true }, + }, + ast: '_!=_(\n b"\\x00\\xff"^#*expr.Constant_BytesValue#,\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n b"\\x00\\xff"~bytes,\n b"ÿ"~bytes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "not_ne_bytes", + expr: "b'\\303\\277' != b'ÿ'", + value: { boolValue: false }, + }, + ast: '_!=_(\n b"ÿ"^#*expr.Constant_BytesValue#,\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n b"ÿ"~bytes,\n b"ÿ"~bytes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_bool", + expr: "false != true", + value: { boolValue: true }, + }, + ast: "_!=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n false~bool,\n true~bool\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_bool", + expr: "true != true", + value: { boolValue: false }, + }, + ast: "_!=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n true~bool,\n true~bool\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_null", + description: + "null can only be equal to null, or else it won't match", + expr: "null != null", + value: { boolValue: false }, + }, + ast: "_!=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_!=_(\n null~null,\n null~null\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_list_empty", + expr: "[] != [1]", + value: { boolValue: true }, + }, + ast: "_!=_(\n []^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n []~list(int),\n [\n 1~int\n ]~list(int)\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_list_empty", + expr: "[] != []", + value: { boolValue: false }, + }, + ast: "_!=_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n []~list(dyn),\n []~list(dyn)\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_list_bool", + expr: "[true, false, true] != [true, true, false]", + value: { boolValue: true }, + }, + ast: "_!=_(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n [\n true~bool,\n false~bool,\n true~bool\n ]~list(bool),\n [\n true~bool,\n true~bool,\n false~bool\n ]~list(bool)\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_list_bool", + expr: "[false, true] != [false, true]", + value: { boolValue: false }, + }, + ast: "_!=_(\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#,\n [\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n [\n false~bool,\n true~bool\n ]~list(bool),\n [\n false~bool,\n true~bool\n ]~list(bool)\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_list_of_list", + expr: "[[]] != [[]]", + value: { boolValue: false }, + }, + ast: "_!=_(\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n [\n []~list(dyn)\n ]~list(list(dyn)),\n [\n []~list(dyn)\n ]~list(list(dyn))\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_map_by_value", + expr: "{'k':'v'} != {'k':'v1'}", + value: { boolValue: true }, + }, + ast: '_!=_(\n {\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n {\n "k"~string:"v"~string\n }~map(string, string),\n {\n "k"~string:"v1"~string\n }~map(string, string)\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_map_by_key", + expr: "{'k':true} != {'k1':true}", + value: { boolValue: true }, + }, + ast: '_!=_(\n {\n "k"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "k1"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n {\n "k"~string:true~bool\n }~map(string, bool),\n {\n "k1"~string:true~bool\n }~map(string, bool)\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "not_ne_map_int_to_float", + expr: "{1:1.0} != {1:1.0}", + value: { boolValue: false }, + }, + ast: "_!=_(\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n {\n 1~int:1~double\n }~map(int, double),\n {\n 1~int:1~double\n }~map(int, double)\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "not_ne_map_key_order", + expr: "{'a':'b','c':'d'} != {'c':'d','a':'b'}", + value: { boolValue: false }, + }, + ast: '_!=_(\n {\n "a"^#*expr.Constant_StringValue#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "c"^#*expr.Constant_StringValue#:"d"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n "c"^#*expr.Constant_StringValue#:"d"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "a"^#*expr.Constant_StringValue#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n {\n "a"~string:"b"~string,\n "c"~string:"d"~string\n }~map(string, string),\n {\n "c"~string:"d"~string,\n "a"~string:"b"~string\n }~map(string, string)\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_mixed_types", + expr: "2u != 2", + disableCheck: true, + value: { boolValue: false }, + }, + ast: "_!=_(\n 2u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:4: found no matching overload for '_!=_' applied to '(uint, int)'\n | 2u != 2\n | ...^", + }, + { + original: { + name: "ne_proto2", + expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto3", + expr: "TestAllTypes{single_int64: 1234, single_string: '1234'} != TestAllTypes{single_int64: 1234, single_string: '1234'}", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int,\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto2_missing_fields_neq", + expr: "TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto3_missing_fields_neq", + expr: "TestAllTypes{single_int64: 1234} != TestAllTypes{single_string: '1234'}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: '_!=_(\n TestAllTypes{\n single_int64:1234^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_string:"1234"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1234~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_string:"1234"~string\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto_nan_not_equal", + description: + "For proto equality, NaN field values are not considered equal.", + expr: "TestAllTypes{single_double: double('NaN')} != TestAllTypes{single_double: double('NaN')}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: '_!=_(\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_double:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_double:double(\n "NaN"~string\n )~double^string_to_double\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto_different_types", + description: + "At runtime, comparing differently typed messages is false.", + expr: "dyn(TestAllTypes{}) != dyn(NestedTestAllTypes{})", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_!=_(\n dyn(\n TestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n NestedTestAllTypes{}^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n dyn(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n )~dyn^to_dyn,\n dyn(\n cel.expr.conformance.proto2.NestedTestAllTypes{}~cel.expr.conformance.proto2.NestedTestAllTypes^cel.expr.conformance.proto2.NestedTestAllTypes\n )~dyn^to_dyn\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "ne_proto2_any_unpack", + description: "Any values should be unpacked and compared.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto2_any_unpack_bytewise_fallback", + description: + "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto3_any_unpack", + description: "Any values should be unpacked and compared.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "ne_proto3_any_unpack_bytewise_fallback", + description: + "If an any field is missing its type_url, the comparison should fallback to a bytewise comparison of the serialized proto.", + expr: "TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001r\\0041234'}} != TestAllTypes{single_any: google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\242\\006\\023\\022\\021r\\0041234\\020\\256\\366\\377\\377\\377\\377\\377\\377\\377\\001'}}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: '_!=_(\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01r\\x041234"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\xa2\\x06\\x13\\x12\\x11r\\x041234\\x10\\xae\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x01"~bytes\n }~any^google.protobuf.Any\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^not_equals', + type: "bool", + }, + ], + }, + { + name: "lt_literal", + tests: [ + { + original: { + name: "lt_int", + expr: "-1 \u003c 0", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n -1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_\u003c_(\n -1~int,\n 0~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "not_lt_int", + expr: "0 \u003c 0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_\u003c_(\n 0~int,\n 0~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "lt_uint", + expr: "0u \u003c 1u", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n 0u~uint,\n 1u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "not_lt_uint", + expr: "2u \u003c 2u", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n 2u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n 2u~uint,\n 2u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "lt_double", + expr: "1.0 \u003c 1.0000001", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n 1^#*expr.Constant_DoubleValue#,\n 1.0000001^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n 1~double,\n 1.0000001~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_double", + description: + "Following IEEE 754, negative zero compares equal to zero", + expr: "-0.0 \u003c 0.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n -0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n -0~double,\n 0~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "lt_string", + expr: "'a' \u003c 'b'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n "a"^#*expr.Constant_StringValue#,\n "b"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "a"~string,\n "b"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "lt_string_empty_to_nonempty", + expr: "'' \u003c 'a'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n ""^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n ""~string,\n "a"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "lt_string_case", + expr: "'Abc' \u003c 'aBC'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n "Abc"^#*expr.Constant_StringValue#,\n "aBC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "Abc"~string,\n "aBC"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "lt_string_length", + expr: "'abc' \u003c 'abcd'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n "abc"^#*expr.Constant_StringValue#,\n "abcd"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "abc"~string,\n "abcd"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "lt_string_diacritical_mark_sensitive", + description: + "Verifies that the we're not using a string comparison function that strips diacritical marks (á)", + expr: "'a' \u003c '\\u00E1'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n "a"^#*expr.Constant_StringValue#,\n "á"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "a"~string,\n "á"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "not_lt_string_empty", + expr: "'' \u003c ''", + value: { boolValue: false }, + }, + ast: '_\u003c_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n ""~string,\n ""~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "not_lt_string_same", + expr: "'abc' \u003c 'abc'", + value: { boolValue: false }, + }, + ast: '_\u003c_(\n "abc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "abc"~string,\n "abc"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "not_lt_string_case_length", + expr: "'a' \u003c 'AB'", + value: { boolValue: false }, + }, + ast: '_\u003c_(\n "a"^#*expr.Constant_StringValue#,\n "AB"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "a"~string,\n "AB"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "unicode_order_lexical", + description: + "Compare the actual code points of the string, instead of decomposing ế into 'e' plus accent modifiers.", + expr: "'f' \u003c '\\u1EBF'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n "f"^#*expr.Constant_StringValue#,\n "ế"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n "f"~string,\n "ế"~string\n)~bool^less_string', + type: "bool", + }, + { + original: { + name: "lt_bytes", + expr: "b'a' \u003c b'b'", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n b"a"^#*expr.Constant_BytesValue#,\n b"b"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n b"a"~bytes,\n b"b"~bytes\n)~bool^less_bytes', + type: "bool", + }, + { + original: { + name: "not_lt_bytes_same", + expr: "b'abc' \u003c b'abc'", + value: { boolValue: false }, + }, + ast: '_\u003c_(\n b"abc"^#*expr.Constant_BytesValue#,\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n b"abc"~bytes,\n b"abc"~bytes\n)~bool^less_bytes', + type: "bool", + }, + { + original: { + name: "not_lt_bytes_width", + expr: "b'á' \u003c b'b'", + value: { boolValue: false }, + }, + ast: '_\u003c_(\n b"á"^#*expr.Constant_BytesValue#,\n b"b"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n b"á"~bytes,\n b"b"~bytes\n)~bool^less_bytes', + type: "bool", + }, + { + original: { + name: "lt_bool_false_first", + expr: "false \u003c true", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n false~bool,\n true~bool\n)~bool^less_bool", + type: "bool", + }, + { + original: { + name: "not_lt_bool_same", + expr: "true \u003c true", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n true~bool,\n true~bool\n)~bool^less_bool", + type: "bool", + }, + { + original: { + name: "not_lt_bool_true_first", + expr: "true \u003c false", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n true~bool,\n false~bool\n)~bool^less_bool", + type: "bool", + }, + { + original: { + name: "lt_list_unsupported", + expr: "[0] \u003c [1]", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003c_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c_' applied to '(list(int), list(int))'\n | [0] \u003c [1]\n | ....^", + }, + { + original: { + name: "lt_map_unsupported", + expr: "{0:'a'} \u003c {1:'b'}", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003c_(\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c {1:'b'}\n | ........^", + }, + { + original: { + name: "lt_null_unsupported", + description: "Ensure _\u003c_ doesn't have a binding for null", + expr: "null \u003c null", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003c_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n null~null,\n null~null\n)~bool^less_duration|less_timestamp", + type: "bool", + }, + { + original: { + name: "lt_mixed_types_error", + expr: "'foo' \u003c 1024", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003c_(\n "foo"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c_' applied to '(string, int)'\n | 'foo' \u003c 1024\n | ......^", + }, + { + original: { + name: "lt_dyn_int_uint", + expr: "dyn(1) \u003c 2u", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "lt_dyn_int_double", + expr: "dyn(1) \u003c 2.0", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "lt_dyn_uint_int", + expr: "dyn(1u) \u003c 2", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "lt_dyn_uint_double", + expr: "dyn(1u) \u003c 2.0", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "lt_dyn_double_int", + expr: "dyn(1.0) \u003c 2", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "lt_dyn_double_uint", + expr: "dyn(1.0) \u003c 2u", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_int_uint", + expr: "dyn(1) \u003c 1u", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_int_double", + expr: "dyn(1) \u003c 1.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_uint_int", + expr: "dyn(1u) \u003c 1", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_uint_double", + expr: "dyn(1u) \u003c 1.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_double_int", + expr: "dyn(1.0) \u003c 1", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_double_uint", + expr: "dyn(1.0) \u003c 1u", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "lt_dyn_int_big_uint", + expr: "dyn(1) \u003c 9223372036854775808u", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "lt_dyn_small_int_uint", + expr: "dyn(-1) \u003c 0u", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_int_big_lossy_double", + expr: "dyn(9223372036854775807) \u003c 9223372036854775808.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "lt_dyn_int_big_lossy_double", + expr: "dyn(9223372036854775807) \u003c 9223372036854777857.0", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_int_small_double", + expr: "dyn(9223372036854775807) \u003c -9223372036854777857.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_int_small_lossy_double", + expr: "dyn(-9223372036854775808) \u003c -9223372036854775809.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_uint_small_int", + expr: "dyn(1u) \u003c -9223372036854775808", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_big_uint_int", + expr: "dyn(9223372036854775808u) \u003c 1", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_uint_small_double", + expr: "dyn(18446744073709551615u) \u003c -1.0", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "lt_dyn_uint_big_double", + expr: "dyn(18446744073709551615u) \u003c 18446744073709590000.0", + value: { boolValue: true }, + }, + ast: "_\u003c_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_double", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_big_double_uint", + expr: "dyn(18446744073709553665.0) \u003c 18446744073709551615u", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_uint64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_big_double_int", + expr: "dyn(9223372036854775808.0) \u003c 9223372036854775807", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_int64", + type: "bool", + }, + { + original: { + name: "not_lt_dyn_small_double_int", + expr: "dyn(-9223372036854775809.0) \u003c -9223372036854775808", + value: { boolValue: false }, + }, + ast: "_\u003c_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_int64", + type: "bool", + }, + ], + }, + { + name: "gt_literal", + tests: [ + { + original: { + name: "gt_int", + expr: "42 \u003e -42", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n 42^#*expr.Constant_Int64Value#,\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n 42~int,\n -42~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "not_gt_int", + expr: "0 \u003e 0", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n 0^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_\u003e_(\n 0~int,\n 0~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "gt_uint", + expr: "48u \u003e 46u", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n 48u^#*expr.Constant_Uint64Value#,\n 46u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n 48u~uint,\n 46u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_uint", + expr: "0u \u003e 999u", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n 0u^#*expr.Constant_Uint64Value#,\n 999u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n 0u~uint,\n 999u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "gt_double", + expr: "1e+1 \u003e 1e+0", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n 10~double,\n 1~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "not_gt_double", + expr: ".99 \u003e 9.9e-1", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n 0.99^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n 0.99~double,\n 0.99~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "gt_string_case", + expr: "'abc' \u003e 'aBc'", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n "abc"^#*expr.Constant_StringValue#,\n "aBc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n "abc"~string,\n "aBc"~string\n)~bool^greater_string', + type: "bool", + }, + { + original: { + name: "gt_string_to_empty", + expr: "'A' \u003e ''", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n "A"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n "A"~string,\n ""~string\n)~bool^greater_string', + type: "bool", + }, + { + original: { + name: "not_gt_string_empty_to_empty", + expr: "'' \u003e ''", + value: { boolValue: false }, + }, + ast: '_\u003e_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n ""~string,\n ""~string\n)~bool^greater_string', + type: "bool", + }, + { + original: { + name: "gt_string_unicode", + expr: "'α' \u003e 'omega'", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n "α"^#*expr.Constant_StringValue#,\n "omega"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n "α"~string,\n "omega"~string\n)~bool^greater_string', + type: "bool", + }, + { + original: { + name: "gt_bytes_one", + expr: "b'\u0001' \u003e b'\u0000'", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n b"\\x01"^#*expr.Constant_BytesValue#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n b"\\x01"~bytes,\n b"\\x00"~bytes\n)~bool^greater_bytes', + type: "bool", + }, + { + original: { + name: "gt_bytes_one_to_empty", + expr: "b'\u0000' \u003e b''", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n b"\\x00"^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n b"\\x00"~bytes,\n b""~bytes\n)~bool^greater_bytes', + type: "bool", + }, + { + original: { + name: "not_gt_bytes_sorting", + expr: "b'\u0000\u0001' \u003e b'\u0001'", + value: { boolValue: false }, + }, + ast: '_\u003e_(\n b"\\x00\\x01"^#*expr.Constant_BytesValue#,\n b"\\x01"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n b"\\x00\\x01"~bytes,\n b"\\x01"~bytes\n)~bool^greater_bytes', + type: "bool", + }, + { + original: { + name: "gt_bool_true_false", + expr: "true \u003e false", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n true~bool,\n false~bool\n)~bool^greater_bool", + type: "bool", + }, + { + original: { + name: "not_gt_bool_false_true", + expr: "false \u003e true", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n false~bool,\n true~bool\n)~bool^greater_bool", + type: "bool", + }, + { + original: { + name: "not_gt_bool_same", + expr: "true \u003e true", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n true~bool,\n true~bool\n)~bool^greater_bool", + type: "bool", + }, + { + original: { + name: "gt_null_unsupported", + expr: "null \u003e null", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003e_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n null~null,\n null~null\n)~bool^greater_duration|greater_timestamp", + type: "bool", + }, + { + original: { + name: "gt_list_unsupported", + expr: "[1] \u003e [0]", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003e_(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003e_' applied to '(list(int), list(int))'\n | [1] \u003e [0]\n | ....^", + }, + { + original: { + name: "gt_map_unsupported", + expr: "{1:'b'} \u003e {0:'a'}", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003e_(\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e {0:'a'}\n | ........^", + }, + { + original: { + name: "gt_mixed_types_error", + expr: "'foo' \u003e 1024", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003e_(\n "foo"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e_' applied to '(string, int)'\n | 'foo' \u003e 1024\n | ......^", + }, + { + original: { + name: "gt_dyn_int_uint", + expr: "dyn(2) \u003e 1u", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "gt_dyn_int_double", + expr: "dyn(2) \u003e 1.0", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "gt_dyn_uint_int", + expr: "dyn(2u) \u003e 1", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "gt_dyn_uint_double", + expr: "dyn(2u) \u003e 1.0", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "gt_dyn_double_int", + expr: "dyn(2.0) \u003e 1", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "gt_dyn_double_uint", + expr: "dyn(2.0) \u003e 1u", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_int_uint", + expr: "dyn(1) \u003e 1u", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_int_double", + expr: "dyn(1) \u003e 1.0", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_uint_int", + expr: "dyn(1u) \u003e 1", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_uint_double", + expr: "dyn(1u) \u003e 1.0", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_double_int", + expr: "dyn(1.0) \u003e 1", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_double_uint", + expr: "dyn(1.0) \u003e 1u", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_int_big_uint", + expr: "dyn(1) \u003e 9223372036854775808u", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_small_int_uint", + expr: "dyn(-1) \u003e 0u", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_int_big_double", + expr: "dyn(9223372036854775807) \u003e 9223372036854775808.0", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_int_small_lossy_double", + description: + "The conversion of the int to double is lossy and the numbers end up being equal", + expr: "dyn(-9223372036854775808) \u003e -9223372036854775809.0", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "gt_dyn_int_small_lossy_double_greater", + expr: "dyn(-9223372036854775808) \u003e -9223372036854777857.0", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "gt_dyn_uint_small_int", + expr: "dyn(1u) \u003e -1", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "gt_dyn_big_uint_int", + expr: "dyn(9223372036854775808u) \u003e 1", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "gt_dyn_uint_small_double", + expr: "dyn(9223372036854775807u) \u003e -1.0", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_uint_big_double", + expr: "dyn(18446744073709551615u) \u003e 18446744073709590000.0", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^greater_double", + type: "bool", + }, + { + original: { + name: "gt_dyn_big_double_uint", + expr: "dyn(18446744073709553665.0) \u003e 18446744073709551615u", + value: { boolValue: true }, + }, + ast: "_\u003e_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_uint64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_big_double_int", + expr: "dyn(9223372036854775808.0) \u003e 9223372036854775807", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_int64", + type: "bool", + }, + { + original: { + name: "not_gt_dyn_small_double_int", + expr: "dyn(-9223372036854775809.0) \u003e -9223372036854775808", + value: { boolValue: false }, + }, + ast: "_\u003e_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_int64", + type: "bool", + }, + ], + }, + { + name: "lte_literal", + tests: [ + { + original: { + name: "lte_int_lt", + expr: "0 \u003c= 1", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 0~int,\n 1~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "lte_int_eq", + expr: "1 \u003c= 1", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 1~int,\n 1~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "not_lte_int_gt", + expr: "1 \u003c= -1", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 1~int,\n -1~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "lte_uint_lt", + expr: "0u \u003c= 1u", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 0u~uint,\n 1u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_uint_eq", + expr: "1u \u003c= 1u", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 1u~uint,\n 1u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_lte_uint_gt", + expr: "1u \u003c= 0u", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 1u~uint,\n 0u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_double_lt", + expr: "0.0 \u003c= 0.1e-31", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 1e-32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 0~double,\n 1e-32~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "lte_double_eq", + expr: "0.0 \u003c= 0e-1", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 0~double,\n 0~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "not_lte_double_gt", + expr: "1.0 \u003c= 0.99", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n 1^#*expr.Constant_DoubleValue#,\n 0.99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 1~double,\n 0.99~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "lte_string_empty", + expr: "'' \u003c= ''", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n ""~string,\n ""~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "lte_string_from_empty", + expr: "'' \u003c= 'a'", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n ""^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n ""~string,\n "a"~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "not_lte_string_to_empty", + expr: "'a' \u003c= ''", + value: { boolValue: false }, + }, + ast: '_\u003c=_(\n "a"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n "a"~string,\n ""~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "lte_string_lexicographical", + expr: "'aBc' \u003c= 'abc'", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n "aBc"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n "aBc"~string,\n "abc"~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "lte_string_unicode_eq", + expr: "'α' \u003c= 'α'", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n "α"^#*expr.Constant_StringValue#,\n "α"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n "α"~string,\n "α"~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "lte_string_unicode_lt", + expr: "'a' \u003c= 'α'", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n "a"^#*expr.Constant_StringValue#,\n "α"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n "a"~string,\n "α"~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "not_lte_string_unicode", + expr: "'α' \u003c= 'a'", + value: { boolValue: false }, + }, + ast: '_\u003c=_(\n "α"^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n "α"~string,\n "a"~string\n)~bool^less_equals_string', + type: "bool", + }, + { + original: { + name: "lte_bytes_empty", + expr: "b'' \u003c= b'\u0000'", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n b""^#*expr.Constant_BytesValue#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n b""~bytes,\n b"\\x00"~bytes\n)~bool^less_equals_bytes', + type: "bool", + }, + { + original: { + name: "not_lte_bytes_length", + expr: "b'\u0001\u0000' \u003c= b'\u0001'", + value: { boolValue: false }, + }, + ast: '_\u003c=_(\n b"\\x01\\x00"^#*expr.Constant_BytesValue#,\n b"\\x01"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n b"\\x01\\x00"~bytes,\n b"\\x01"~bytes\n)~bool^less_equals_bytes', + type: "bool", + }, + { + original: { + name: "lte_bool_false_true", + expr: "false \u003c= true", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n false~bool,\n true~bool\n)~bool^less_equals_bool", + type: "bool", + }, + { + original: { + name: "lte_bool_false_false", + expr: "false \u003c= false", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n false~bool,\n false~bool\n)~bool^less_equals_bool", + type: "bool", + }, + { + original: { + name: "lte_bool_true_false", + expr: "true \u003c= false", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n true~bool,\n false~bool\n)~bool^less_equals_bool", + type: "bool", + }, + { + original: { + name: "lte_null_unsupported", + expr: "null \u003c= null", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003c=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n null~null,\n null~null\n)~bool^less_equals_duration|less_equals_timestamp", + type: "bool", + }, + { + original: { + name: "lte_list_unsupported", + expr: "[0] \u003c= [0]", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003c=_(\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: found no matching overload for '_\u003c=_' applied to '(list(int), list(int))'\n | [0] \u003c= [0]\n | ....^", + }, + { + original: { + name: "lte_map_unsupported", + expr: "{0:'a'} \u003c= {1:'b'}", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003c=_(\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003c=_' applied to '(map(int, string), map(int, string))'\n | {0:'a'} \u003c= {1:'b'}\n | ........^", + }, + { + original: { + name: "lte_mixed_types_error", + expr: "'foo' \u003c= 1024", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003c=_(\n "foo"^#*expr.Constant_StringValue#,\n 1024^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003c=_' applied to '(string, int)'\n | 'foo' \u003c= 1024\n | ......^", + }, + { + original: { + name: "lte_dyn_int_uint", + expr: "dyn(1) \u003c= 2u", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_dyn_int_double", + expr: "dyn(1) \u003c= 2.0", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "lte_dyn_uint_int", + expr: "dyn(1u) \u003c= 2", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "lte_dyn_uint_double", + expr: "dyn(1u) \u003c= 2.0", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n 2~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "lte_dyn_double_int", + expr: "dyn(1.0) \u003c= 2", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "lte_dyn_double_uint", + expr: "dyn(1.0) \u003c= 2u", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1~double\n )~dyn^to_dyn,\n 2u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_int_uint", + expr: "dyn(2) \u003c= 1u", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_int_double", + expr: "dyn(2) \u003c= 1.0", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_uint_int", + expr: "dyn(2u) \u003c= 1", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_uint_double", + expr: "dyn(2u) \u003c= 1.0", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_double_int", + expr: "dyn(2.0) \u003c= 1", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_double_uint", + expr: "dyn(2.0) \u003c= 1u", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_dyn_int_big_uint", + expr: "dyn(1) \u003c= 9223372036854775808u", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_dyn_small_int_uint", + expr: "dyn(-1) \u003c= 0u", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_dyn_int_big_double", + expr: "dyn(9223372036854775807) \u003c= 9223372036854775808.0", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "lte_dyn_int_small_lossy_double", + description: + "The conversion of the int to double is lossy and the numbers end up being equal", + expr: "dyn(-9223372036854775808) \u003c= -9223372036854775809.0", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_int_small_lossy_double_less", + expr: "dyn(-9223372036854775808) \u003c= -9223372036854777857.0", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_uint_small_int", + expr: "dyn(1u) \u003c= -9223372036854775808", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_big_uint_int", + expr: "dyn(9223372036854775808u) \u003c= 1", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_uint_small_double", + expr: "dyn(18446744073709551615u) \u003c= -1.0", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "lte_dyn_uint_big_double", + expr: "dyn(18446744073709551615u) \u003c= 18446744073709590000.0", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.844674407370959e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.844674407370959e+19~double\n)~bool^less_equals_double", + type: "bool", + }, + { + original: { + name: "not_lte_dyn_big_double_uint", + expr: "dyn(18446744073709553665.0) \u003c= 18446744073709551615u", + value: { boolValue: false }, + }, + ast: "_\u003c=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^less_equals_uint64", + type: "bool", + }, + { + original: { + name: "lte_dyn_big_double_int", + expr: "dyn(9223372036854775808.0) \u003c= 9223372036854775807", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "lte_dyn_small_double_int", + expr: "dyn(-9223372036854775809.0) \u003c= -9223372036854775808", + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^less_equals_int64", + type: "bool", + }, + ], + }, + { + name: "gte_literal", + tests: [ + { + original: { + name: "gte_int_gt", + expr: "0 \u003e= -1", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n 0^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 0~int,\n -1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_int_eq", + expr: "999 \u003e= 999", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 999^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 999~int,\n 999~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "not_gte_int_lt", + expr: "999 \u003e= 1000", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n 999^#*expr.Constant_Int64Value#,\n 1000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 999~int,\n 1000~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_uint_gt", + expr: "1u \u003e= 0u", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 1u~uint,\n 0u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "gte_uint_eq", + expr: "0u \u003e= 0u", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n 0u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 0u~uint,\n 0u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_gte_uint_lt", + expr: "1u \u003e= 10u", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 1u~uint,\n 10u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "gte_double_gt", + expr: "1e+1 \u003e= 1e+0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n 10^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 10~double,\n 1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_double_eq", + expr: "9.80665 \u003e= 9.80665e+0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n 9.80665^#*expr.Constant_DoubleValue#,\n 9.80665^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 9.80665~double,\n 9.80665~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "not_gte_double_lt", + expr: "0.9999 \u003e= 1.0", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n 0.9999^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n 0.9999~double,\n 1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_string_empty", + expr: "'' \u003e= ''", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n ""~string,\n ""~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "gte_string_to_empty", + expr: "'a' \u003e= ''", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n "a"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "a"~string,\n ""~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "gte_string_empty_to_nonempty", + expr: "'' \u003e= 'a'", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n ""^#*expr.Constant_StringValue#,\n "a"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n ""~string,\n "a"~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "gte_string_length", + expr: "'abcd' \u003e= 'abc'", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n "abcd"^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "abcd"~string,\n "abc"~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "not_gte_string_lexicographical", + expr: "'abc' \u003e= 'abd'", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n "abc"^#*expr.Constant_StringValue#,\n "abd"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "abc"~string,\n "abd"~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "gte_string_unicode_eq", + expr: "'τ' \u003e= 'τ'", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n "τ"^#*expr.Constant_StringValue#,\n "τ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "τ"~string,\n "τ"~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "gte_string_unicode_gt", + expr: "'τ' \u003e= 't'", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n "τ"^#*expr.Constant_StringValue#,\n "t"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "τ"~string,\n "t"~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "not_get_string_unicode", + expr: "'t' \u003e= 'τ'", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n "t"^#*expr.Constant_StringValue#,\n "τ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "t"~string,\n "τ"~string\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "gte_bytes_to_empty", + expr: "b'\u0000' \u003e= b''", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n b"\\x00"^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n b"\\x00"~bytes,\n b""~bytes\n)~bool^greater_equals_bytes', + type: "bool", + }, + { + original: { + name: "not_gte_bytes_empty_to_nonempty", + expr: "b'' \u003e= b'\u0000'", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n b""^#*expr.Constant_BytesValue#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n b""~bytes,\n b"\\x00"~bytes\n)~bool^greater_equals_bytes', + type: "bool", + }, + { + original: { + name: "gte_bytes_samelength", + expr: "b'\u0000\u0001' \u003e= b'\u0001\u0000'", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n b"\\x00\\x01"^#*expr.Constant_BytesValue#,\n b"\\x01\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n b"\\x00\\x01"~bytes,\n b"\\x01\\x00"~bytes\n)~bool^greater_equals_bytes', + type: "bool", + }, + { + original: { + name: "gte_bool_gt", + expr: "true \u003e= false", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n true~bool,\n false~bool\n)~bool^greater_equals_bool", + type: "bool", + }, + { + original: { + name: "gte_bool_eq", + expr: "true \u003e= true", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n true~bool,\n true~bool\n)~bool^greater_equals_bool", + type: "bool", + }, + { + original: { + name: "not_gte_bool_lt", + expr: "false \u003e= true", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n false~bool,\n true~bool\n)~bool^greater_equals_bool", + type: "bool", + }, + { + original: { + name: "gte_null_unsupported", + expr: "null \u003e= null", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003e=_(\n null^#*expr.Constant_NullValue#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n null~null,\n null~null\n)~bool^greater_equals_duration|greater_equals_timestamp", + type: "bool", + }, + { + original: { + name: "gte_list_unsupported", + expr: "['y'] \u003e= ['x']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003e=_(\n [\n "y"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n [\n "x"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(list(string), list(string))'\n | ['y'] \u003e= ['x']\n | ......^", + }, + { + original: { + name: "gte_map_unsupported", + expr: "{1:'b'} \u003e= {0:'a'}", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003e=_(\n {\n 1^#*expr.Constant_Int64Value#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n {\n 0^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for '_\u003e=_' applied to '(map(int, string), map(int, string))'\n | {1:'b'} \u003e= {0:'a'}\n | ........^", + }, + { + original: { + name: "gte_mixed_types_error", + expr: "'foo' \u003e= 1.0", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_\u003e=_(\n "foo"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:7: found no matching overload for '_\u003e=_' applied to '(string, double)'\n | 'foo' \u003e= 1.0\n | ......^", + }, + { + original: { + name: "gte_dyn_int_uint", + expr: "dyn(2) \u003e= 1u", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "gte_dyn_int_double", + expr: "dyn(2) \u003e= 1.0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 2~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_dyn_uint_int", + expr: "dyn(2u) \u003e= 1", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_dyn_uint_double", + expr: "dyn(2u) \u003e= 1.0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_dyn_double_int", + expr: "dyn(2.0) \u003e= 1", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_dyn_double_uint", + expr: "dyn(2.0) \u003e= 1u", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 2~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_int_uint", + expr: "dyn(0) \u003e= 1u", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_int_double", + expr: "dyn(0) \u003e= 1.0", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 0~int\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_uint_int", + expr: "dyn(0u) \u003e= 1", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_uint_double", + expr: "dyn(0u) \u003e= 1.0", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 0u~uint\n )~dyn^to_dyn,\n 1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_double_int", + expr: "dyn(0.0) \u003e= 1", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_double_uint", + expr: "dyn(0.0) \u003e= 1u", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 0~double\n )~dyn^to_dyn,\n 1u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_int_big_uint", + expr: "dyn(1) \u003e= 9223372036854775808u", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 9223372036854775808u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_small_int_uint", + expr: "dyn(-1) \u003e= 0u", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n -1~int\n )~dyn^to_dyn,\n 0u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "gte_dyn_int_big_lossy_double", + expr: "dyn(9223372036854775807) \u003e= 9223372036854775808.0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854776e+18~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_int_big_double", + expr: "dyn(9223372036854775807) \u003e= 9223372036854777857.0", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 9223372036854775807~int\n )~dyn^to_dyn,\n 9.223372036854778e+18~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_dyn_int_small_lossy_double_equal", + description: + "The conversion of the int to double is lossy and the numbers end up being equal", + expr: "dyn(-9223372036854775808) \u003e= -9223372036854775809.0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854776e+18~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_dyn_int_small_lossy_double_greater", + expr: "dyn(-9223372036854775808) \u003e= -9223372036854777857.0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n -9223372036854775808^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9.223372036854778e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n -9223372036854775808~int\n )~dyn^to_dyn,\n -9.223372036854778e+18~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_dyn_uint_small_int", + expr: "dyn(1u) \u003e= -1", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n -1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_dyn_big_uint_int", + expr: "dyn(9223372036854775808u) \u003e= 1", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 9223372036854775808u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 9223372036854775808u~uint\n )~dyn^to_dyn,\n 1~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_dyn_uint_small_double", + expr: "dyn(9223372036854775807u) \u003e= -1.0", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 9223372036854775807u~uint\n )~dyn^to_dyn,\n -1~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "not_gte_dyn_uint_big_double", + expr: "dyn(18446744073709551615u) \u003e= 18446744073709553665.0", + value: { boolValue: false }, + }, + ast: "_\u003e=_(\n dyn(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 18446744073709551615u~uint\n )~dyn^to_dyn,\n 1.8446744073709556e+19~double\n)~bool^greater_equals_double", + type: "bool", + }, + { + original: { + name: "gte_dyn_big_double_uint", + expr: "dyn(18446744073709553665.0) \u003e= 18446744073709551615u", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 1.8446744073709556e+19^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 1.8446744073709556e+19~double\n )~dyn^to_dyn,\n 18446744073709551615u~uint\n)~bool^greater_equals_uint64", + type: "bool", + }, + { + original: { + name: "gte_dyn_big_double_int", + expr: "dyn(9223372036854775808.0) \u003e= 9223372036854775807", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n 9.223372036854776e+18~double\n )~dyn^to_dyn,\n 9223372036854775807~int\n)~bool^greater_equals_int64", + type: "bool", + }, + { + original: { + name: "gte_dyn_small_double_int", + expr: "dyn(-9223372036854775809.0) \u003e= -9223372036854775808", + value: { boolValue: true }, + }, + ast: "_\u003e=_(\n dyn(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003e=_(\n dyn(\n -9.223372036854776e+18~double\n )~dyn^to_dyn,\n -9223372036854775808~int\n)~bool^greater_equals_int64", + type: "bool", + }, + ], + }, + { + name: "in_list_literal", + tests: [ + { + original: { + name: "elem_not_in_empty_list", + expr: "'empty' in []", + value: { boolValue: false }, + }, + ast: '@in(\n "empty"^#*expr.Constant_StringValue#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "empty"~string,\n []~list(string)\n)~bool^in_list', + type: "bool", + }, + { + original: { + name: "elem_in_list", + expr: "'elem' in ['elem', 'elemA', 'elemB']", + value: { boolValue: true }, + }, + ast: '@in(\n "elem"^#*expr.Constant_StringValue#,\n [\n "elem"^#*expr.Constant_StringValue#,\n "elemA"^#*expr.Constant_StringValue#,\n "elemB"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "elem"~string,\n [\n "elem"~string,\n "elemA"~string,\n "elemB"~string\n ]~list(string)\n)~bool^in_list', + type: "bool", + }, + { + original: { + name: "elem_not_in_list", + expr: "'not' in ['elem1', 'elem2', 'elem3']", + value: { boolValue: false }, + }, + ast: '@in(\n "not"^#*expr.Constant_StringValue#,\n [\n "elem1"^#*expr.Constant_StringValue#,\n "elem2"^#*expr.Constant_StringValue#,\n "elem3"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "not"~string,\n [\n "elem1"~string,\n "elem2"~string,\n "elem3"~string\n ]~list(string)\n)~bool^in_list', + type: "bool", + }, + { + original: { + name: "elem_in_mixed_type_list", + description: + "Set membership tests should succeed if the 'elem' exists in a mixed element type list.", + expr: "'elem' in [1, 'elem', 2]", + value: { boolValue: true }, + }, + ast: '@in(\n "elem"^#*expr.Constant_StringValue#,\n [\n 1^#*expr.Constant_Int64Value#,\n "elem"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "elem"~string,\n [\n 1~int,\n "elem"~string,\n 2~int\n ]~list(dyn)\n)~bool^in_list', + type: "bool", + }, + { + original: { + name: "elem_in_mixed_type_list_cross_type", + description: + "Set membership tests should return false due to the introduction of heterogeneous-equality. Set membership via 'in' is equivalent to the macro exists() behavior.", + expr: "'elem' in [1u, 'str', 2, b'bytes']", + value: { boolValue: false }, + }, + ast: '@in(\n "elem"^#*expr.Constant_StringValue#,\n [\n 1u^#*expr.Constant_Uint64Value#,\n "str"^#*expr.Constant_StringValue#,\n 2^#*expr.Constant_Int64Value#,\n b"bytes"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "elem"~string,\n [\n 1u~uint,\n "str"~string,\n 2~int,\n b"bytes"~bytes\n ]~list(dyn)\n)~bool^in_list', + type: "bool", + }, + ], + }, + { + name: "in_map_literal", + tests: [ + { + original: { + name: "key_not_in_empty_map", + expr: "'empty' in {}", + value: { boolValue: false }, + }, + ast: '@in(\n "empty"^#*expr.Constant_StringValue#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "empty"~string,\n {}~map(string, dyn)\n)~bool^in_map', + type: "bool", + }, + { + original: { + name: "key_in_map", + expr: "'key' in {'key':'1', 'other':'2'}", + value: { boolValue: true }, + }, + ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n "key"^#*expr.Constant_StringValue#:"1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "other"^#*expr.Constant_StringValue#:"2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "key"~string,\n {\n "key"~string:"1"~string,\n "other"~string:"2"~string\n }~map(string, string)\n)~bool^in_map', + type: "bool", + }, + { + original: { + name: "key_not_in_map", + expr: "'key' in {'lock':1, 'gate':2}", + value: { boolValue: false }, + }, + ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n "lock"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "gate"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "key"~string,\n {\n "lock"~string:1~int,\n "gate"~string:2~int\n }~map(string, int)\n)~bool^in_map', + type: "bool", + }, + { + original: { + name: "key_in_mixed_key_type_map", + description: + "Map keys are of mixed type, but since the key is present the result is true.", + expr: "'key' in {3:3.0, 'key':2u}", + value: { boolValue: true }, + }, + ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n 3^#*expr.Constant_Int64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "key"^#*expr.Constant_StringValue#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "key"~string,\n {\n 3~int:3~double,\n "key"~string:2u~uint\n }~map(dyn, dyn)\n)~bool^in_map', + type: "bool", + }, + { + original: { + name: "key_in_mixed_key_type_map_cross_type", + expr: "'key' in {1u:'str', 2:b'bytes'}", + value: { boolValue: false }, + }, + ast: '@in(\n "key"^#*expr.Constant_StringValue#,\n {\n 1u^#*expr.Constant_Uint64Value#:"str"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:b"bytes"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "key"~string,\n {\n 1u~uint:"str"~string,\n 2~int:b"bytes"~bytes\n }~map(dyn, dyn)\n)~bool^in_map', + type: "bool", + }, + ], + }, + { + name: "bound", + tests: [ + { + original: { + name: "bytes_gt_left_false", + expr: "x \u003e b'\u0000'", + typeEnv: [ + { name: "x", ident: { type: { primitive: "BYTES" } } }, + ], + bindings: { x: { value: { bytesValue: "AA==" } } }, + value: { boolValue: false }, + }, + ast: '_\u003e_(\n x^#*expr.Expr_IdentExpr#,\n b"\\x00"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n x~bytes^x,\n b"\\x00"~bytes\n)~bool^greater_bytes', + type: "bool", + }, + { + original: { + name: "int_lte_right_true", + expr: "123 \u003c= x", + typeEnv: [ + { name: "x", ident: { type: { primitive: "INT64" } } }, + ], + bindings: { x: { value: { int64Value: "124" } } }, + value: { boolValue: true }, + }, + ast: "_\u003c=_(\n 123^#*expr.Constant_Int64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c=_(\n 123~int,\n x~int^x\n)~bool^less_equals_int64", + type: "bool", + }, + { + original: { + name: "bool_lt_right_true", + expr: "false \u003c x", + typeEnv: [ + { name: "x", ident: { type: { primitive: "BOOL" } } }, + ], + bindings: { x: { value: { boolValue: true } } }, + value: { boolValue: true }, + }, + ast: "_\u003c_(\n false^#*expr.Constant_BoolValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u003c_(\n false~bool,\n x~bool^x\n)~bool^less_bool", + type: "bool", + }, + { + original: { + name: "double_ne_left_false", + expr: "x != 9.8", + typeEnv: [ + { name: "x", ident: { type: { primitive: "DOUBLE" } } }, + ], + bindings: { x: { value: { doubleValue: 9.8 } } }, + value: { boolValue: false }, + }, + ast: "_!=_(\n x^#*expr.Expr_IdentExpr#,\n 9.8^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n x~double^x,\n 9.8~double\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "map_ne_right_false", + expr: "{'a':'b','c':'d'} != x", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "c" }, + value: { stringValue: "d" }, + }, + { + key: { stringValue: "a" }, + value: { stringValue: "b" }, + }, + ], + }, + }, + }, + }, + value: { boolValue: false }, + }, + ast: '_!=_(\n {\n "a"^#*expr.Constant_StringValue#:"b"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "c"^#*expr.Constant_StringValue#:"d"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n {\n "a"~string:"b"~string,\n "c"~string:"d"~string\n }~map(string, string),\n x~map(string, string)^x\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "null_eq_left_true", + description: + "A comparison _==_ against null only binds if the type is determined to be null or we skip the type checking", + expr: "x == null", + typeEnv: [{ name: "x", ident: { type: { null: null } } }], + bindings: { x: { value: { nullValue: null } } }, + value: { boolValue: true }, + }, + ast: "_==_(\n x^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n x~null^x,\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "list_eq_right_false", + expr: "[1, 2] == x", + typeEnv: [ + { + name: "x", + ident: { + type: { listType: { elemType: { primitive: "INT64" } } }, + }, + }, + ], + bindings: { + x: { + value: { + listValue: { + values: [{ int64Value: "2" }, { int64Value: "1" }], + }, + }, + }, + }, + value: { boolValue: false }, + }, + ast: "_==_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n [\n 1~int,\n 2~int\n ]~list(int),\n x~list(int)^x\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "string_gte_right_true", + expr: "'abcd' \u003e= x", + typeEnv: [ + { name: "x", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { x: { value: { stringValue: "abc" } } }, + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n "abcd"^#*expr.Constant_StringValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n "abcd"~string,\n x~string^x\n)~bool^greater_equals_string', + type: "bool", + }, + { + original: { + name: "uint_eq_right_false", + expr: "999u == x", + typeEnv: [ + { name: "x", ident: { type: { primitive: "UINT64" } } }, + ], + bindings: { x: { value: { uint64Value: "1000" } } }, + value: { boolValue: false }, + }, + ast: "_==_(\n 999u^#*expr.Constant_Uint64Value#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_==_(\n 999u~uint,\n x~uint^x\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "null_lt_right_no_such_overload", + description: + "There is no _\u003c_ operation for null, even if both operands are null", + expr: "null \u003c x", + disableCheck: true, + bindings: { x: { value: { nullValue: null } } }, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "_\u003c_(\n null^#*expr.Constant_NullValue#,\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:8: undeclared reference to 'x' (in container '')\n | null \u003c x\n | .......^", + }, + ], + }, + ], + }, + { + name: "conversions", + suites: [ + { + name: "bytes", + tests: [ + { + original: { + name: "string_empty", + expr: "bytes('')", + value: { bytesValue: "" }, + }, + ast: 'bytes(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bytes(\n ""~string\n)~bytes^string_to_bytes', + type: "bytes", + }, + { + original: { + name: "string", + expr: "bytes('abc')", + value: { bytesValue: "YWJj" }, + }, + ast: 'bytes(\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bytes(\n "abc"~string\n)~bytes^string_to_bytes', + type: "bytes", + }, + { + original: { + name: "string_unicode", + expr: "bytes('ÿ')", + value: { bytesValue: "w78=" }, + }, + ast: 'bytes(\n "ÿ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bytes(\n "ÿ"~string\n)~bytes^string_to_bytes', + type: "bytes", + }, + { + original: { + name: "string_unicode_vs_literal", + expr: "bytes('\\377') == b'\\377'", + value: { boolValue: false }, + }, + ast: '_==_(\n bytes(\n "ÿ"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n b"\\xff"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n bytes(\n "ÿ"~string\n )~bytes^string_to_bytes,\n b"\\xff"~bytes\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "double", + tests: [ + { + original: { + name: "int_zero", + expr: "double(0)", + value: { doubleValue: 0 }, + }, + ast: "double(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "double(\n 0~int\n)~double^int64_to_double", + type: "double", + }, + { + original: { + name: "int_pos", + expr: "double(1000000000000)", + value: { doubleValue: 1000000000000 }, + }, + ast: "double(\n 1000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n 1000000000000~int\n)~double^int64_to_double", + type: "double", + }, + { + original: { + name: "int_neg", + expr: "double(-1000000000000000)", + value: { doubleValue: -1000000000000000 }, + }, + ast: "double(\n -1000000000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n -1000000000000000~int\n)~double^int64_to_double", + type: "double", + }, + { + original: { + name: "int_min_exact", + description: "Smallest contiguous representable int (-2^53).", + expr: "double(-9007199254740992)", + value: { doubleValue: -9007199254740992 }, + }, + ast: "double(\n -9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n -9007199254740992~int\n)~double^int64_to_double", + type: "double", + }, + { + original: { + name: "int_max_exact", + description: "Largest contiguous representable int (2^53).", + expr: "double(9007199254740992)", + value: { doubleValue: 9007199254740992 }, + }, + ast: "double(\n 9007199254740992^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n 9007199254740992~int\n)~double^int64_to_double", + type: "double", + }, + { + original: { + name: "int_range", + description: "Largest signed 64-bit. Rounds to nearest double.", + expr: "double(9223372036854775807)", + value: { doubleValue: 9223372036854776000 }, + }, + ast: "double(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n 9223372036854775807~int\n)~double^int64_to_double", + type: "double", + }, + { + original: { + name: "uint_zero", + expr: "double(0u)", + value: { doubleValue: 0 }, + }, + ast: "double(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "double(\n 0u~uint\n)~double^uint64_to_double", + type: "double", + }, + { + original: { + name: "uint_pos", + expr: "double(123u)", + value: { doubleValue: 123 }, + }, + ast: "double(\n 123u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "double(\n 123u~uint\n)~double^uint64_to_double", + type: "double", + }, + { + original: { + name: "uint_max_exact", + description: "Largest contiguous representable int (2^53).", + expr: "double(9007199254740992u)", + value: { doubleValue: 9007199254740992 }, + }, + ast: "double(\n 9007199254740992u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n 9007199254740992u~uint\n)~double^uint64_to_double", + type: "double", + }, + { + original: { + name: "uint_range", + description: "Largest unsigned 64-bit.", + expr: "double(18446744073709551615u)", + value: { doubleValue: 18446744073709552000 }, + }, + ast: "double(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "double(\n 18446744073709551615u~uint\n)~double^uint64_to_double", + type: "double", + }, + { + original: { + name: "string_zero", + expr: "double('0')", + value: { doubleValue: 0 }, + }, + ast: 'double(\n "0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'double(\n "0"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_zero_dec", + expr: "double('0.0')", + value: { doubleValue: 0 }, + }, + ast: 'double(\n "0.0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'double(\n "0.0"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_neg_zero", + expr: "double('-0.0')", + value: { doubleValue: 0 }, + }, + ast: 'double(\n "-0.0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'double(\n "-0.0"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_no_dec", + expr: "double('123')", + value: { doubleValue: 123 }, + }, + ast: 'double(\n "123"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'double(\n "123"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_pos", + expr: "double('123.456')", + value: { doubleValue: 123.456 }, + }, + ast: 'double(\n "123.456"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'double(\n "123.456"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_neg", + expr: "double('-987.654')", + value: { doubleValue: -987.654 }, + }, + ast: 'double(\n "-987.654"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'double(\n "-987.654"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_exp_pos_pos", + expr: "double('6.02214e23')", + value: { doubleValue: 6.02214e23 }, + }, + ast: 'double(\n "6.02214e23"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'double(\n "6.02214e23"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_exp_pos_neg", + expr: "double('1.38e-23')", + value: { doubleValue: 1.38e-23 }, + }, + ast: 'double(\n "1.38e-23"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'double(\n "1.38e-23"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_exp_neg_pos", + expr: "double('-84.32e7')", + value: { doubleValue: -843200000 }, + }, + ast: 'double(\n "-84.32e7"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'double(\n "-84.32e7"~string\n)~double^string_to_double', + type: "double", + }, + { + original: { + name: "string_exp_neg_neg", + expr: "double('-5.43e-21')", + value: { doubleValue: -5.43e-21 }, + }, + ast: 'double(\n "-5.43e-21"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'double(\n "-5.43e-21"~string\n)~double^string_to_double', + type: "double", + }, + ], + }, + { + name: "dyn", + tests: [ + { + original: { + name: "dyn_heterogeneous_list", + description: "No need to disable type checking.", + expr: "type(dyn([1, 'one']))", + value: { typeValue: "list" }, + }, + ast: 'type(\n dyn(\n [\n 1^#*expr.Constant_Int64Value#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'type(\n dyn(\n [\n 1~int,\n "one"~string\n ]~list(dyn)\n )~dyn^to_dyn\n)~type(dyn)^type', + type: "type(dyn)", + }, + ], + }, + { + name: "int", + tests: [ + { + original: { + name: "uint", + expr: "int(42u)", + value: { int64Value: "42" }, + }, + ast: "int(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n 42u~uint\n)~int^uint64_to_int64", + type: "int", + }, + { + original: { + name: "uint_zero", + expr: "int(0u)", + value: { int64Value: "0" }, + }, + ast: "int(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n 0u~uint\n)~int^uint64_to_int64", + type: "int", + }, + { + original: { + name: "uint_max_exact", + expr: "int(9223372036854775807u)", + value: { int64Value: "9223372036854775807" }, + }, + ast: "int(\n 9223372036854775807u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n 9223372036854775807u~uint\n)~int^uint64_to_int64", + type: "int", + }, + { + original: { + name: "uint_range", + expr: "int(18446744073709551615u)", + evalError: { errors: [{ message: "range error" }] }, + }, + ast: "int(\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n 18446744073709551615u~uint\n)~int^uint64_to_int64", + type: "int", + }, + { + original: { + name: "double_round_neg", + expr: "int(-123.456)", + value: { int64Value: "-123" }, + }, + ast: "int(\n -123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n -123.456~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_truncate", + expr: "int(1.9)", + value: { int64Value: "1" }, + }, + ast: "int(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n 1.9~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_truncate_neg", + expr: "int(-7.9)", + value: { int64Value: "-7" }, + }, + ast: "int(\n -7.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n -7.9~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_half_pos", + expr: "int(11.5)", + value: { int64Value: "11" }, + }, + ast: "int(\n 11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n 11.5~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_half_neg", + expr: "int(-3.5)", + value: { int64Value: "-3" }, + }, + ast: "int(\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n -3.5~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_big_exact", + description: + "Beyond exact range (2^53), but no loss of precision (2^55).", + expr: "int(double(36028797018963968))", + value: { int64Value: "36028797018963968" }, + }, + ast: "int(\n double(\n 36028797018963968^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n double(\n 36028797018963968~int\n )~double^int64_to_double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_big_precision", + description: + "Beyond exact range (2^53), but loses precision (2^55 + 1).", + expr: "int(double(36028797018963969))", + value: { int64Value: "36028797018963968" }, + }, + ast: "int(\n double(\n 36028797018963969^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n double(\n 36028797018963969~int\n )~double^int64_to_double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_int_max_range", + description: + "The double(2^63-1) cast produces a floating point value outside the int range", + expr: "int(9223372036854775807.0)", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "int(\n 9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n 9.223372036854776e+18~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_int_min_range", + description: + "The double(-2^63) cast produces a floating point value outside the int range", + expr: "int(-9223372036854775808.0)", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "int(\n -9.223372036854776e+18^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n -9.223372036854776e+18~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_range", + expr: "int(1e99)", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "int(\n 1e+99^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n 1e+99~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "string", + expr: "int('987')", + value: { int64Value: "987" }, + }, + ast: 'int(\n "987"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'int(\n "987"~string\n)~int^string_to_int64', + type: "int", + }, + { + original: { + name: "timestamp", + expr: "int(timestamp('2004-09-16T23:59:59Z'))", + value: { int64Value: "1095379199" }, + }, + ast: 'int(\n timestamp(\n "2004-09-16T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'int(\n timestamp(\n "2004-09-16T23:59:59Z"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64', + type: "int", + }, + ], + }, + { + name: "string", + tests: [ + { + original: { + name: "int", + expr: "string(123)", + value: { stringValue: "123" }, + }, + ast: "string(\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "string(\n 123~int\n)~string^int64_to_string", + type: "string", + }, + { + original: { + name: "int_neg", + expr: "string(-456)", + value: { stringValue: "-456" }, + }, + ast: "string(\n -456^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "string(\n -456~int\n)~string^int64_to_string", + type: "string", + }, + { + original: { + name: "uint", + expr: "string(9876u)", + value: { stringValue: "9876" }, + }, + ast: "string(\n 9876u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "string(\n 9876u~uint\n)~string^uint64_to_string", + type: "string", + }, + { + original: { + name: "double", + expr: "string(123.456)", + value: { stringValue: "123.456" }, + }, + ast: "string(\n 123.456^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "string(\n 123.456~double\n)~string^double_to_string", + type: "string", + }, + { + original: { + name: "double_hard", + expr: "string(-4.5e-3)", + value: { stringValue: "-0.0045" }, + }, + ast: "string(\n -0.0045^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "string(\n -0.0045~double\n)~string^double_to_string", + type: "string", + }, + { + original: { + name: "bytes", + expr: "string(b'abc')", + value: { stringValue: "abc" }, + }, + ast: 'string(\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'string(\n b"abc"~bytes\n)~string^bytes_to_string', + type: "string", + }, + { + original: { + name: "bytes_unicode", + expr: "string(b'\\303\\277')", + value: { stringValue: "ÿ" }, + }, + ast: 'string(\n b"ÿ"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'string(\n b"ÿ"~bytes\n)~string^bytes_to_string', + type: "string", + }, + { + original: { + name: "bytes_invalid", + expr: "string(b'\\000\\xff')", + evalError: { errors: [{ message: "invalid UTF-8" }] }, + }, + ast: 'string(\n b"\\x00\\xff"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'string(\n b"\\x00\\xff"~bytes\n)~string^bytes_to_string', + type: "string", + }, + ], + }, + { + name: "type", + tests: [ + { + original: { + name: "bool", + expr: "type(true)", + value: { typeValue: "bool" }, + }, + ast: "type(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "type(\n true~bool\n)~type(bool)^type", + type: "type(bool)", + }, + { + original: { + name: "bool_denotation", + expr: "bool", + value: { typeValue: "bool" }, + }, + ast: "bool^#*expr.Expr_IdentExpr#", + checkedAst: "bool~type(bool)^bool", + type: "type(bool)", + }, + { + original: { + name: "dyn_no_denotation", + expr: "dyn", + disableCheck: true, + evalError: { errors: [{ message: "unknown variable" }] }, + }, + ast: "dyn^#*expr.Expr_IdentExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'dyn' (in container '')\n | dyn\n | ^", + }, + { + original: { + name: "int", + expr: "type(0)", + value: { typeValue: "int" }, + }, + ast: "type(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "type(\n 0~int\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "int_denotation", + expr: "int", + value: { typeValue: "int" }, + }, + ast: "int^#*expr.Expr_IdentExpr#", + checkedAst: "int~type(int)^int", + type: "type(int)", + }, + { + original: { + name: "eq_same", + expr: "type(true) == type(false)", + value: { boolValue: true }, + }, + ast: "_==_(\n type(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n type(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n type(\n true~bool\n )~type(bool)^type,\n type(\n false~bool\n )~type(bool)^type\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "uint", + expr: "type(64u)", + value: { typeValue: "uint" }, + }, + ast: "type(\n 64u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "type(\n 64u~uint\n)~type(uint)^type", + type: "type(uint)", + }, + { + original: { + name: "uint_denotation", + expr: "uint", + value: { typeValue: "uint" }, + }, + ast: "uint^#*expr.Expr_IdentExpr#", + checkedAst: "uint~type(uint)^uint", + type: "type(uint)", + }, + { + original: { + name: "double", + expr: "type(3.14)", + value: { typeValue: "double" }, + }, + ast: "type(\n 3.14^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "type(\n 3.14~double\n)~type(double)^type", + type: "type(double)", + }, + { + original: { + name: "double_denotation", + expr: "double", + value: { typeValue: "double" }, + }, + ast: "double^#*expr.Expr_IdentExpr#", + checkedAst: "double~type(double)^double", + type: "type(double)", + }, + { + original: { + name: "null_type", + expr: "type(null)", + value: { typeValue: "null_type" }, + }, + ast: "type(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "type(\n null~null\n)~type(null)^type", + type: "type(null)", + }, + { + original: { + name: "null_type_denotation", + expr: "null_type", + value: { typeValue: "null_type" }, + }, + ast: "null_type^#*expr.Expr_IdentExpr#", + checkedAst: "null_type~type(null)^null_type", + type: "type(null)", + }, + { + original: { + name: "string", + expr: "type('foo')", + value: { typeValue: "string" }, + }, + ast: 'type(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'type(\n "foo"~string\n)~type(string)^type', + type: "type(string)", + }, + { + original: { + name: "string_denotation", + expr: "string", + value: { typeValue: "string" }, + }, + ast: "string^#*expr.Expr_IdentExpr#", + checkedAst: "string~type(string)^string", + type: "type(string)", + }, + { + original: { + name: "bytes", + expr: "type(b'\\xff')", + value: { typeValue: "bytes" }, + }, + ast: 'type(\n b"\\xff"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'type(\n b"\\xff"~bytes\n)~type(bytes)^type', + type: "type(bytes)", + }, + { + original: { + name: "bytes_denotation", + expr: "bytes", + value: { typeValue: "bytes" }, + }, + ast: "bytes^#*expr.Expr_IdentExpr#", + checkedAst: "bytes~type(bytes)^bytes", + type: "type(bytes)", + }, + { + original: { + name: "list", + expr: "type([1, 2, 3])", + value: { typeValue: "list" }, + }, + ast: "type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~type(list(int))^type", + type: "type(list(int))", + }, + { + original: { + name: "list_denotation", + expr: "list", + value: { typeValue: "list" }, + }, + ast: "list^#*expr.Expr_IdentExpr#", + checkedAst: "list~type(list(dyn))^list", + type: "type(list(dyn))", + }, + { + original: { + name: "lists_monomorphic", + expr: "type([1, 2, 3]) == type(['one', 'two', 'three'])", + value: { boolValue: true }, + }, + ast: '_==_(\n type(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n [\n "one"^#*expr.Constant_StringValue#,\n "two"^#*expr.Constant_StringValue#,\n "three"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n type(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n )~type(list(int))^type,\n type(\n [\n "one"~string,\n "two"~string,\n "three"~string\n ]~list(string)\n )~type(list(string))^type\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "map", + expr: "type({4: 16})", + value: { typeValue: "map" }, + }, + ast: "type(\n {\n 4^#*expr.Constant_Int64Value#:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n {\n 4~int:16~int\n }~map(int, int)\n)~type(map(int, int))^type", + type: "type(map(int, int))", + }, + { + original: { + name: "map_denotation", + expr: "map", + value: { typeValue: "map" }, + }, + ast: "map^#*expr.Expr_IdentExpr#", + checkedAst: "map~type(map(dyn, dyn))^map", + type: "type(map(dyn, dyn))", + }, + { + original: { + name: "map_monomorphic", + expr: "type({'one': 1}) == type({1: 'one'})", + value: { boolValue: true }, + }, + ast: '_==_(\n type(\n {\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n {\n 1^#*expr.Constant_Int64Value#:"one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n type(\n {\n "one"~string:1~int\n }~map(string, int)\n )~type(map(string, int))^type,\n type(\n {\n 1~int:"one"~string\n }~map(int, string)\n )~type(map(int, string))^type\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_diff", + expr: "type(7) == type(7u)", + value: { boolValue: false }, + }, + ast: "_==_(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n type(\n 7~int\n )~type(int)^type,\n type(\n 7u~uint\n )~type(uint)^type\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "neq_same", + expr: "type(0.0) != type(-0.0)", + value: { boolValue: false }, + }, + ast: "_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n -0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n -0~double\n )~type(double)^type\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "neq_diff", + expr: "type(0.0) != type(0)", + value: { boolValue: true }, + }, + ast: "_!=_(\n type(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n type(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n type(\n 0~double\n )~type(double)^type,\n type(\n 0~int\n )~type(int)^type\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "meta", + expr: "type(type(7)) == type(type(7u))", + value: { boolValue: true }, + }, + ast: "_==_(\n type(\n type(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n type(\n type(\n 7u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n type(\n type(\n 7~int\n )~type(int)^type\n )~type(type(int))^type,\n type(\n type(\n 7u~uint\n )~type(uint)^type\n )~type(type(uint))^type\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "type", + expr: "type(int)", + value: { typeValue: "type" }, + }, + ast: "type(\n int^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: "type(\n int~type(int)^int\n)~type(type(int))^type", + type: "type(type(int))", + }, + { + original: { + name: "type_denotation", + expr: "type", + value: { typeValue: "type" }, + }, + ast: "type^#*expr.Expr_IdentExpr#", + checkedAst: "type~type(type)^type", + type: "type(type)", + }, + { + original: { + name: "type_type", + expr: "type(type)", + value: { typeValue: "type" }, + }, + ast: "type(\n type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n type~type(type)^type\n)~type(type(type))^type", + type: "type(type(type))", + }, + ], + }, + { + name: "uint", + tests: [ + { + original: { + name: "int", + expr: "uint(1729)", + value: { uint64Value: "1729" }, + }, + ast: "uint(\n 1729^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n 1729~int\n)~uint^int64_to_uint64", + type: "uint", + }, + { + original: { + name: "int_max", + expr: "uint(9223372036854775807)", + value: { uint64Value: "9223372036854775807" }, + }, + ast: "uint(\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "uint(\n 9223372036854775807~int\n)~uint^int64_to_uint64", + type: "uint", + }, + { + original: { + name: "int_neg", + expr: "uint(-1)", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "uint(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n -1~int\n)~uint^int64_to_uint64", + type: "uint", + }, + { + original: { + name: "double", + expr: "uint(3.14159265)", + value: { uint64Value: "3" }, + }, + ast: "uint(\n 3.14159265^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n 3.14159265~double\n)~uint^double_to_uint64", + type: "uint", + }, + { + original: { + name: "double_truncate", + expr: "uint(1.9)", + value: { uint64Value: "1" }, + }, + ast: "uint(\n 1.9^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n 1.9~double\n)~uint^double_to_uint64", + type: "uint", + }, + { + original: { + name: "double_half", + expr: "uint(25.5)", + value: { uint64Value: "25" }, + }, + ast: "uint(\n 25.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n 25.5~double\n)~uint^double_to_uint64", + type: "uint", + }, + { + original: { + name: "double_big_exact", + description: + "Beyond exact range (2^53), but no loss of precision (2^55).", + expr: "uint(double(36028797018963968u))", + value: { uint64Value: "36028797018963968" }, + }, + ast: "uint(\n double(\n 36028797018963968u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "uint(\n double(\n 36028797018963968u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64", + type: "uint", + }, + { + original: { + name: "double_big_precision", + description: + "Beyond exact range (2^53), but loses precision (2^55 + 1).", + expr: "uint(double(36028797018963969u))", + value: { uint64Value: "36028797018963968" }, + }, + ast: "uint(\n double(\n 36028797018963969u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "uint(\n double(\n 36028797018963969u~uint\n )~double^uint64_to_double\n)~uint^double_to_uint64", + type: "uint", + }, + { + original: { + name: "double_uint_max_range", + description: + "The exact conversion of uint max as a double does not round trip.", + expr: "int(18446744073709551615.0)", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "int(\n 1.8446744073709552e+19^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n 1.8446744073709552e+19~double\n)~int^double_to_int64", + type: "int", + }, + { + original: { + name: "double_range_beyond_uint", + expr: "uint(6.022e23)", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "uint(\n 6.022e+23^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n 6.022e+23~double\n)~uint^double_to_uint64", + type: "uint", + }, + { + original: { + name: "string", + expr: "uint('300')", + value: { uint64Value: "300" }, + }, + ast: 'uint(\n "300"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'uint(\n "300"~string\n)~uint^string_to_uint64', + type: "uint", + }, + ], + }, + { + name: "bool", + tests: [ + { + original: { + name: "string_1", + expr: "bool('1')", + value: { boolValue: true }, + }, + ast: 'bool(\n "1"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "1"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_t", + expr: "bool('t')", + value: { boolValue: true }, + }, + ast: 'bool(\n "t"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "t"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_true_lowercase", + expr: "bool('true')", + value: { boolValue: true }, + }, + ast: 'bool(\n "true"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "true"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_true_uppercase", + expr: "bool('TRUE')", + value: { boolValue: true }, + }, + ast: 'bool(\n "TRUE"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "TRUE"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_true_pascalcase", + expr: "bool('True')", + value: { boolValue: true }, + }, + ast: 'bool(\n "True"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "True"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_0", + expr: "bool('0')", + value: { boolValue: false }, + }, + ast: 'bool(\n "0"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "0"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_f", + expr: "bool('f')", + value: { boolValue: false }, + }, + ast: 'bool(\n "f"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "f"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_false_lowercase", + expr: "bool('false')", + value: { boolValue: false }, + }, + ast: 'bool(\n "false"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "false"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_false_uppercase", + expr: "bool('FALSE')", + value: { boolValue: false }, + }, + ast: 'bool(\n "FALSE"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "FALSE"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_false_pascalcase", + expr: "bool('False')", + value: { boolValue: false }, + }, + ast: 'bool(\n "False"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "False"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_true_badcase", + expr: "bool('TrUe')", + evalError: { errors: [{ message: "Type conversion error" }] }, + }, + ast: 'bool(\n "TrUe"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "TrUe"~string\n)~bool^string_to_bool', + type: "bool", + }, + { + original: { + name: "string_false_badcase", + expr: "bool('FaLsE')", + evalError: { errors: [{ message: "Type conversion error" }] }, + }, + ast: 'bool(\n "FaLsE"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bool(\n "FaLsE"~string\n)~bool^string_to_bool', + type: "bool", + }, + ], + }, + { + name: "identity", + tests: [ + { + original: { + name: "bool", + expr: "bool(true)", + value: { boolValue: true }, + }, + ast: "bool(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "bool(\n true~bool\n)~bool^bool_to_bool", + type: "bool", + }, + { + original: { + name: "int", + expr: "int(1)", + value: { int64Value: "1" }, + }, + ast: "int(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "int(\n 1~int\n)~int^int64_to_int64", + type: "int", + }, + { + original: { + name: "uint", + expr: "uint(1u)", + value: { uint64Value: "1" }, + }, + ast: "uint(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "uint(\n 1u~uint\n)~uint^uint64_to_uint64", + type: "uint", + }, + { + original: { + name: "double", + expr: "double(5.5)", + value: { doubleValue: 5.5 }, + }, + ast: "double(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "double(\n 5.5~double\n)~double^double_to_double", + type: "double", + }, + { + original: { + name: "string", + expr: "string('hello')", + value: { stringValue: "hello" }, + }, + ast: 'string(\n "hello"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'string(\n "hello"~string\n)~string^string_to_string', + type: "string", + }, + { + original: { + name: "bytes", + expr: "bytes(b'abc')", + value: { bytesValue: "YWJj" }, + }, + ast: 'bytes(\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'bytes(\n b"abc"~bytes\n)~bytes^bytes_to_bytes', + type: "bytes", + }, + { + original: { + name: "duration", + expr: "duration(duration('100s')) == duration('100s')", + value: { boolValue: true }, + }, + ast: '_==_(\n duration(\n duration(\n "100s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "100s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n duration(\n duration(\n "100s"~string\n )~duration^string_to_duration\n )~duration^duration_to_duration,\n duration(\n "100s"~string\n )~duration^string_to_duration\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "timestamp", + expr: "timestamp(timestamp(1000000000)) == timestamp(1000000000)", + value: { boolValue: true }, + }, + ast: "_==_(\n timestamp(\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n 1000000000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n timestamp(\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n )~timestamp^timestamp_to_timestamp,\n timestamp(\n 1000000000~int\n )~timestamp^int64_to_timestamp\n)~bool^equals", + type: "bool", + }, + ], + }, + ], + }, + { + name: "dynamic", + suites: [ + { + name: "int32", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Int32Value{value: -123}", + value: { int64Value: "-123" }, + }, + ast: "google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Int32Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int32Value", + type: "wrapper(int)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Int32Value{value: -123}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.Int32Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int32Value{value: -123}.value\n | .......................................^", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.Int32Value{}", + value: { int64Value: "0" }, + }, + ast: "google.protobuf.Int32Value{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Int32Value{}~wrapper(int)^google.protobuf.Int32Value", + type: "wrapper(int)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.Int32Value" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.Int32Value", + value: 2000000, + }, + }, + }, + }, + value: { int64Value: "2000000" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(int)^x", + type: "wrapper(int)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_int32_wrapper: 432}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32Wrapper: 432, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_int32_wrapper: 0}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32Wrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_max", + expr: "TestAllTypes{single_int32_wrapper: 2147483647}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32Wrapper: 2147483647, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_min", + expr: "TestAllTypes{single_int32_wrapper: -2147483648}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32Wrapper: -2147483648, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_range", + expr: "TestAllTypes{single_int32_wrapper: 12345678900}", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "range error" }] }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:12345678900^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:12345678900~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper", + container: "cel.expr.conformance.proto2", + value: { int64Value: "642" }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper", + container: "cel.expr.conformance.proto2", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "field_read_proto2_unset", + expr: "TestAllTypes{}.single_int32_wrapper", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_int32_wrapper: -975}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32Wrapper: -975, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_int32_wrapper: 0}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32Wrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_max", + expr: "TestAllTypes{single_int32_wrapper: 2147483647}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32Wrapper: 2147483647, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:2147483647^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:2147483647~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_min", + expr: "TestAllTypes{single_int32_wrapper: -2147483648}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32Wrapper: -2147483648, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:-2147483648^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-2147483648~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_range", + expr: "TestAllTypes{single_int32_wrapper: -998877665544332211}", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "range error" }] }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:-998877665544332211^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-998877665544332211~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_int32_wrapper: 642}.single_int32_wrapper", + container: "cel.expr.conformance.proto3", + value: { int64Value: "642" }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:642^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:642~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "field_read_proto3_zero", + expr: "TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper", + container: "cel.expr.conformance.proto3", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "field_read_proto3_unset", + expr: "TestAllTypes{}.single_int32_wrapper", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + ], + }, + { + name: "int64", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Int64Value{value: -123}", + value: { int64Value: "-123" }, + }, + ast: "google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Int64Value{\n value:-123~int\n}~wrapper(int)^google.protobuf.Int64Value", + type: "wrapper(int)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Int64Value{value: -123}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.Int64Value{\n value:-123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:40: type 'wrapper(int)' does not support field selection\n | google.protobuf.Int64Value{value: -123}.value\n | .......................................^", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.Int64Value{}", + value: { int64Value: "0" }, + }, + ast: "google.protobuf.Int64Value{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Int64Value{}~wrapper(int)^google.protobuf.Int64Value", + type: "wrapper(int)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.Int64Value" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.Int64Value", + value: "2000000", + }, + }, + }, + }, + value: { int64Value: "2000000" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(int)^x", + type: "wrapper(int)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_int64_wrapper: 432}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt64Wrapper: "432", + }, + }, + }, + ast: "TestAllTypes{\n single_int64_wrapper:432^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:432~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_int64_wrapper: 0}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt64Wrapper: "0", + }, + }, + }, + ast: "TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_int64_wrapper: -975}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64Wrapper: "-975", + }, + }, + }, + ast: "TestAllTypes{\n single_int64_wrapper:-975^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-975~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_int64_wrapper: 0}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64Wrapper: "0", + }, + }, + }, + ast: "TestAllTypes{\n single_int64_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "uint32", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.UInt32Value{value: 123u}", + value: { uint64Value: "123" }, + }, + ast: "google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.UInt32Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt32Value", + type: "wrapper(uint)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.UInt32Value{value: 123u}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.UInt32Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt32Value{value: 123u}.value\n | ........................................^", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.UInt32Value{}", + value: { uint64Value: "0" }, + }, + ast: "google.protobuf.UInt32Value{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.UInt32Value{}~wrapper(uint)^google.protobuf.UInt32Value", + type: "wrapper(uint)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.UInt32Value" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.UInt32Value", + value: 2000000, + }, + }, + }, + }, + value: { uint64Value: "2000000" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(uint)^x", + type: "wrapper(uint)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_uint32_wrapper: 432u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint32Wrapper: 432, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_uint32_wrapper: 0u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint32Wrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_max", + expr: "TestAllTypes{single_uint32_wrapper: 4294967295u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint32Wrapper: 4294967295, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_range", + expr: "TestAllTypes{single_uint32_wrapper: 6111222333u}", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "range error" }] }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_uint32_wrapper: 975u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint32Wrapper: 975, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_uint32_wrapper: 0u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint32Wrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_max", + expr: "TestAllTypes{single_uint32_wrapper: 4294967295u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint32Wrapper: 4294967295, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:4294967295u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:4294967295u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_range", + expr: "TestAllTypes{single_uint32_wrapper: 6111222333u}", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "range error" }] }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:6111222333u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:6111222333u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_uint32_wrapper: 258u}.single_uint32_wrapper", + container: "cel.expr.conformance.proto2", + value: { uint64Value: "258" }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:258u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:258u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)", + type: "wrapper(uint)", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_uint32_wrapper: 0u}.single_uint32_wrapper", + container: "cel.expr.conformance.proto2", + value: { uint64Value: "0" }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)", + type: "wrapper(uint)", + }, + { + original: { + name: "field_read_proto2_unset", + expr: "TestAllTypes{}.single_uint32_wrapper", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint32_wrapper~wrapper(uint)", + type: "wrapper(uint)", + }, + ], + }, + { + name: "uint64", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.UInt64Value{value: 123u}", + value: { uint64Value: "123" }, + }, + ast: "google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.UInt64Value{\n value:123u~uint\n}~wrapper(uint)^google.protobuf.UInt64Value", + type: "wrapper(uint)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.UInt64Value{value: 123u}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.UInt64Value{\n value:123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:41: type 'wrapper(uint)' does not support field selection\n | google.protobuf.UInt64Value{value: 123u}.value\n | ........................................^", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.UInt64Value{}", + value: { uint64Value: "0" }, + }, + ast: "google.protobuf.UInt64Value{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.UInt64Value{}~wrapper(uint)^google.protobuf.UInt64Value", + type: "wrapper(uint)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.UInt64Value" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.UInt64Value", + value: "2000000", + }, + }, + }, + }, + value: { uint64Value: "2000000" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(uint)^x", + type: "wrapper(uint)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_uint64_wrapper: 432u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint64Wrapper: "432", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:432u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:432u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_uint64_wrapper: 0u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint64Wrapper: "0", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_uint64_wrapper: 975u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint64Wrapper: "975", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:975u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:975u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_uint64_wrapper: 0u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint64Wrapper: "0", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_uint64_wrapper: 5123123123u}.single_uint64_wrapper", + container: "cel.expr.conformance.proto2", + value: { uint64Value: "5123123123" }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:5123123123u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:5123123123u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)", + type: "wrapper(uint)", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_uint64_wrapper: 0u}.single_uint64_wrapper", + container: "cel.expr.conformance.proto2", + value: { uint64Value: "0" }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:0u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:0u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)", + type: "wrapper(uint)", + }, + { + original: { + name: "field_read_proto2_unset", + expr: "TestAllTypes{}.single_uint64_wrapper", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_uint64_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_uint64_wrapper~wrapper(uint)", + type: "wrapper(uint)", + }, + ], + }, + { + name: "float", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.FloatValue{value: -1.5e3}", + value: { doubleValue: -1500 }, + }, + ast: "google.protobuf.FloatValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.FloatValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.FloatValue", + type: "wrapper(double)", + }, + { + original: { + name: "literal_not_double", + description: + "Use a number with no exact representation to make sure we actually narrow to a float.", + expr: "google.protobuf.FloatValue{value: 1.333} == 1.333", + value: { boolValue: false }, + }, + ast: "_==_(\n google.protobuf.FloatValue{\n value:1.333^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1.333^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{\n value:1.333~double\n }~wrapper(double)^google.protobuf.FloatValue,\n 1.333~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.FloatValue{value: 3.1416}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.FloatValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:42: type 'wrapper(double)' does not support field selection\n | google.protobuf.FloatValue{value: 3.1416}.value\n | .........................................^", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.FloatValue{}", + value: { doubleValue: 0 }, + }, + ast: "google.protobuf.FloatValue{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.FloatValue{}~wrapper(double)^google.protobuf.FloatValue", + type: "wrapper(double)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.FloatValue" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.FloatValue", + value: -1250000, + }, + }, + }, + }, + value: { doubleValue: -1250000 }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(double)^x", + type: "wrapper(double)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_float_wrapper: 86.75}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: 86.75, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_float_wrapper: 0.0}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_subnorm", + description: + "Subnormal single floats range from ~1e-38 to ~1e-45.", + expr: "TestAllTypes{single_float_wrapper: 1e-40}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: 1e-40, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_round_to_zero", + description: + "Subnormal single floats range from ~1e-38 to ~1e-45.", + expr: "TestAllTypes{single_float_wrapper: 1e-50}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:1e-50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-50~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_range", + description: "Single float max is about 3.4e38", + expr: "TestAllTypes{single_float_wrapper: 1.4e55}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: "Infinity", + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_float_wrapper: -12.375}.single_float_wrapper", + container: "cel.expr.conformance.proto2", + value: { doubleValue: -12.375 }, + }, + ast: "TestAllTypes{\n single_float_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper", + container: "cel.expr.conformance.proto2", + value: { doubleValue: 0 }, + }, + ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto2_unset", + expr: "TestAllTypes{}.single_float_wrapper", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_float_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_float_wrapper: -9.75}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFloatWrapper: -9.75, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_float_wrapper: 0.0}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFloatWrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_subnorm", + description: + "Subnormal single floats range from ~1e-38 to ~1e-45.", + expr: "TestAllTypes{single_float_wrapper: 1e-40}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: 1e-40, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:1e-40^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:1e-40~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_round_to_zero", + expr: "TestAllTypes{single_float_wrapper: -9.9e-100}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFloatWrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:-9.9e-100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e-100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_range", + description: "Single float min is about -3.4e38", + expr: "TestAllTypes{single_float_wrapper: -9.9e100}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFloatWrapper: "-Infinity", + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_float_wrapper: 64.25}.single_float_wrapper", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 64.25 }, + }, + ast: "TestAllTypes{\n single_float_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto3_zero", + expr: "TestAllTypes{single_float_wrapper: 0.0}.single_float_wrapper", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 0 }, + }, + ast: "TestAllTypes{\n single_float_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto3_unset", + expr: "TestAllTypes{}.single_float_wrapper", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_float_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_float_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + ], + }, + { + name: "double", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.DoubleValue{value: -1.5e3}", + value: { doubleValue: -1500 }, + }, + ast: "google.protobuf.DoubleValue{\n value:-1500^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.DoubleValue{\n value:-1500~double\n}~wrapper(double)^google.protobuf.DoubleValue", + type: "wrapper(double)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.DoubleValue{value: 3.1416}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.DoubleValue{\n value:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:43: type 'wrapper(double)' does not support field selection\n | google.protobuf.DoubleValue{value: 3.1416}.value\n | ..........................................^", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.DoubleValue{}", + value: { doubleValue: 0 }, + }, + ast: "google.protobuf.DoubleValue{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.DoubleValue{}~wrapper(double)^google.protobuf.DoubleValue", + type: "wrapper(double)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.DoubleValue" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.DoubleValue", + value: -1250000, + }, + }, + }, + }, + value: { doubleValue: -1250000 }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(double)^x", + type: "wrapper(double)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_double_wrapper: 86.75}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleDoubleWrapper: 86.75, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:86.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:86.75~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_double_wrapper: 0.0}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleDoubleWrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_range", + expr: "TestAllTypes{single_double_wrapper: 1.4e55}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleDoubleWrapper: 1.4e55, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:1.4e+55^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:1.4e+55~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_double_wrapper: -12.375}.single_double_wrapper", + container: "cel.expr.conformance.proto2", + value: { doubleValue: -12.375 }, + }, + ast: "TestAllTypes{\n single_double_wrapper:-12.375^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:-12.375~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_int32_wrapper: 0}.single_int32_wrapper", + container: "cel.expr.conformance.proto2", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:0~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "field_read_proto2_unset", + expr: "TestAllTypes{}.single_double_wrapper", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_double_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_double_wrapper: -9.75}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleDoubleWrapper: -9.75, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:-9.75^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.75~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_double_wrapper: 0.0}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleDoubleWrapper: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_range", + expr: "TestAllTypes{single_double_wrapper: -9.9e100}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleDoubleWrapper: -9.9e100, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:-9.9e+100^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:-9.9e+100~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_double_wrapper: 64.25}.single_double_wrapper", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 64.25 }, + }, + ast: "TestAllTypes{\n single_double_wrapper:64.25^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:64.25~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto3_zero", + expr: "TestAllTypes{single_double_wrapper: 0.0}.single_double_wrapper", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 0 }, + }, + ast: "TestAllTypes{\n single_double_wrapper:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + { + original: { + name: "field_read_proto3_unset", + expr: "TestAllTypes{}.single_double_wrapper", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_double_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_double_wrapper~wrapper(double)", + type: "wrapper(double)", + }, + ], + }, + { + name: "bool", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.BoolValue{value: true}", + value: { boolValue: true }, + }, + ast: "google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.BoolValue{\n value:true~bool\n}~wrapper(bool)^google.protobuf.BoolValue", + type: "wrapper(bool)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.BoolValue{value: true}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:39: type 'wrapper(bool)' does not support field selection\n | google.protobuf.BoolValue{value: true}.value\n | ......................................^", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.BoolValue{}", + value: { boolValue: false }, + }, + ast: "google.protobuf.BoolValue{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.BoolValue{}~wrapper(bool)^google.protobuf.BoolValue", + type: "wrapper(bool)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.BoolValue" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.BoolValue", + value: true, + }, + }, + }, + }, + value: { boolValue: true }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(bool)^x", + type: "wrapper(bool)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_bool_wrapper: true}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBoolWrapper: true, + }, + }, + }, + ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_false", + expr: "TestAllTypes{single_bool_wrapper: false}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBoolWrapper: false, + }, + }, + }, + ast: "TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_bool_wrapper: true}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBoolWrapper: true, + }, + }, + }, + ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_false", + expr: "TestAllTypes{single_bool_wrapper: false}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBoolWrapper: false, + }, + }, + }, + ast: "TestAllTypes{\n single_bool_wrapper:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "string", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.StringValue{value: 'foo'}", + value: { stringValue: "foo" }, + }, + ast: 'google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.StringValue{\n value:"foo"~string\n}~wrapper(string)^google.protobuf.StringValue', + type: "wrapper(string)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.StringValue{value: 'foo'}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#', + error: + "ERROR: \u003cinput\u003e:1:42: type 'wrapper(string)' does not support field selection\n | google.protobuf.StringValue{value: 'foo'}.value\n | .........................................^", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.StringValue{}", + value: { stringValue: "" }, + }, + ast: "google.protobuf.StringValue{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.StringValue{}~wrapper(string)^google.protobuf.StringValue", + type: "wrapper(string)", + }, + { + original: { + name: "literal_unicode", + expr: "google.protobuf.StringValue{value: 'flambé'}", + value: { stringValue: "flambé" }, + }, + ast: 'google.protobuf.StringValue{\n value:"flambé"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.StringValue{\n value:"flambé"~string\n}~wrapper(string)^google.protobuf.StringValue', + type: "wrapper(string)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.StringValue" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.StringValue", + value: "bar", + }, + }, + }, + }, + value: { stringValue: "bar" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(string)^x", + type: "wrapper(string)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_string_wrapper: 'baz'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleStringWrapper: "baz", + }, + }, + }, + ast: 'TestAllTypes{\n single_string_wrapper:"baz"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:"baz"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{single_string_wrapper: ''}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleStringWrapper: "", + }, + }, + }, + ast: 'TestAllTypes{\n single_string_wrapper:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:""~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_string_wrapper: 'bletch'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleStringWrapper: "bletch", + }, + }, + }, + ast: 'TestAllTypes{\n single_string_wrapper:"bletch"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:"bletch"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{single_string_wrapper: ''}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleStringWrapper: "", + }, + }, + }, + ast: 'TestAllTypes{\n single_string_wrapper:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:""~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "bytes", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.BytesValue{value: b'foo\\123'}", + value: { bytesValue: "Zm9vUw==" }, + }, + ast: 'google.protobuf.BytesValue{\n value:b"fooS"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.BytesValue{\n value:b"fooS"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue', + type: "wrapper(bytes)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.BytesValue{value: b'foo'}.value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.BytesValue{\n value:b"foo"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.value^#*expr.Expr_SelectExpr#', + error: + "ERROR: \u003cinput\u003e:1:42: type 'wrapper(bytes)' does not support field selection\n | google.protobuf.BytesValue{value: b'foo'}.value\n | .........................................^", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.BytesValue{}", + value: { bytesValue: "" }, + }, + ast: "google.protobuf.BytesValue{}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.BytesValue{}~wrapper(bytes)^google.protobuf.BytesValue", + type: "wrapper(bytes)", + }, + { + original: { + name: "literal_unicode", + expr: "google.protobuf.BytesValue{value: b'flambé'}", + value: { bytesValue: "ZmxhbWLDqQ==" }, + }, + ast: 'google.protobuf.BytesValue{\n value:b"flambé"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.BytesValue{\n value:b"flambé"~bytes\n}~wrapper(bytes)^google.protobuf.BytesValue', + type: "wrapper(bytes)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.BytesValue" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.BytesValue", + value: "YmFy", + }, + }, + }, + }, + value: { bytesValue: "YmFy" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~wrapper(bytes)^x", + type: "wrapper(bytes)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_bytes_wrapper: b'baz'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBytesWrapper: "YmF6", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes_wrapper:b"baz"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b"baz"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{single_bytes_wrapper: b''}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBytesWrapper: "", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes_wrapper:b""^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b""~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_bytes_wrapper: b'bletch'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBytesWrapper: "YmxldGNo", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes_wrapper:b"bletch"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b"bletch"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{single_bytes_wrapper: b''}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBytesWrapper: "", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes_wrapper:b""^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b""~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "list", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.ListValue{values: [3.0, 'foo', null]}", + value: { + listValue: { + values: [ + { doubleValue: 3 }, + { stringValue: "foo" }, + { nullValue: null }, + ], + }, + }, + }, + ast: 'google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n "foo"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.ListValue{\n values:[\n 3~double,\n "foo"~string,\n null~null\n ]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue', + type: "list(dyn)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.ListValue{values: [3.0, 'foo', null]}.values", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.ListValue{\n values:[\n 3^#*expr.Constant_DoubleValue#,\n "foo"^#*expr.Constant_StringValue#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.values^#*expr.Expr_SelectExpr#', + error: + "ERROR: \u003cinput\u003e:1:54: type 'list(dyn)' does not support field selection\n | google.protobuf.ListValue{values: [3.0, 'foo', null]}.values\n | .....................................................^", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.ListValue{values: []}", + value: { listValue: {} }, + }, + ast: "google.protobuf.ListValue{\n values:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.ListValue{\n values:[]~list(dyn)\n}~list(dyn)^google.protobuf.ListValue", + type: "list(dyn)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.ListValue" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/google.protobuf.ListValue", + value: ["bar", ["a", "b"]], + }, + }, + }, + }, + value: { + listValue: { + values: [ + { stringValue: "bar" }, + { + listValue: { + values: [{ stringValue: "a" }, { stringValue: "b" }], + }, + }, + ], + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~list(dyn)^x", + type: "list(dyn)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{list_value: [1.0, 'one']}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + listValue: [1, "one"], + }, + }, + }, + ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{list_value: []}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + listValue: [], + }, + }, + }, + ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{list_value: [1.0, 'one']}.list_value", + container: "cel.expr.conformance.proto2", + value: { + listValue: { + values: [{ doubleValue: 1 }, { stringValue: "one" }], + }, + }, + }, + ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)', + type: "list(dyn)", + }, + { + original: { + name: "field_read_proto2_empty", + expr: "TestAllTypes{list_value: []}.list_value", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "field_read_proto2_unset", + description: "Not a wrapper type, so doesn't convert to null.", + expr: "TestAllTypes{}.list_value", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.list_value~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{list_value: [1.0, 'one']}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + listValue: [1, "one"], + }, + }, + }, + ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{list_value: []}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + listValue: [], + }, + }, + }, + ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{list_value: [1.0, 'one']}.list_value", + container: "cel.expr.conformance.proto3", + value: { + listValue: { + values: [{ doubleValue: 1 }, { stringValue: "one" }], + }, + }, + }, + ast: 'TestAllTypes{\n list_value:[\n 1^#*expr.Constant_DoubleValue#,\n "one"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n list_value:[\n 1~double,\n "one"~string\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)', + type: "list(dyn)", + }, + { + original: { + name: "field_read_proto3_empty", + expr: "TestAllTypes{list_value: []}.list_value", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n list_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "field_read_proto3_unset", + description: "Not a wrapper type, so doesn't convert to null.", + expr: "TestAllTypes{}.list_value", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.list_value~list(dyn)", + type: "list(dyn)", + }, + ], + }, + { + name: "struct", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "uno" }, + value: { doubleValue: 1 }, + }, + { + key: { stringValue: "dos" }, + value: { doubleValue: 2 }, + }, + ], + }, + }, + }, + ast: 'google.protobuf.Struct{\n fields:{\n "uno"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "dos"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.Struct{\n fields:{\n "uno"~string:1~double,\n "dos"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct', + type: "map(string, dyn)", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Struct{fields: {'uno': 1.0, 'dos': 2.0}}.fields", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.Struct{\n fields:{\n "uno"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "dos"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.fields^#*expr.Expr_SelectExpr#', + checkedAst: + 'google.protobuf.Struct{\n fields:{\n "uno"~string:1~double,\n "dos"~string:2~double\n }~map(string, double)\n}~map(string, dyn)^google.protobuf.Struct.fields~dyn', + type: "dyn", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.Struct{fields: {}}", + value: { mapValue: {} }, + }, + ast: "google.protobuf.Struct{\n fields:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Struct{\n fields:{}~map(string, dyn)\n}~map(string, dyn)^google.protobuf.Struct", + type: "map(string, dyn)", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Struct" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Struct", + value: { first: "Abraham", last: "Lincoln" }, + }, + }, + }, + }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "first" }, + value: { stringValue: "Abraham" }, + }, + { + key: { stringValue: "last" }, + value: { stringValue: "Lincoln" }, + }, + ], + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~map(string, dyn)^x", + type: "map(string, dyn)", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleStruct: { deux: 2, un: 1 }, + }, + }, + }, + ast: 'TestAllTypes{\n single_struct:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{single_struct: {}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleStruct: {}, + }, + }, + }, + ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_bad", + expr: "TestAllTypes{single_struct: {1: 'uno'}}", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "bad key type" }] }, + }, + ast: 'TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + error: + "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_struct: {'one': 1.0}}.single_struct", + container: "cel.expr.conformance.proto2", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "one" }, + value: { doubleValue: 1 }, + }, + ], + }, + }, + }, + ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n "one"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)', + type: "map(string, dyn)", + }, + { + original: { + name: "field_read_proto2_empty", + expr: "TestAllTypes{single_struct: {}}.single_struct", + container: "cel.expr.conformance.proto2", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)", + type: "map(string, dyn)", + }, + { + original: { + name: "field_read_proto2_unset", + description: "Not a wrapper type, so doesn't convert to null.", + expr: "TestAllTypes{}.single_struct", + container: "cel.expr.conformance.proto2", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_struct~map(string, dyn)", + type: "map(string, dyn)", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_struct: {'un': 1.0, 'deux': 2.0}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleStruct: { deux: 2, un: 1 }, + }, + }, + }, + ast: 'TestAllTypes{\n single_struct:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{single_struct: {}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleStruct: {}, + }, + }, + }, + ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_bad", + expr: "TestAllTypes{single_struct: {1: 'uno'}}", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "bad key type" }] }, + }, + ast: 'TestAllTypes{\n single_struct:{\n 1^#*expr.Constant_Int64Value#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + error: + "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'map(int, string)'\n | TestAllTypes{single_struct: {1: 'uno'}}\n | ..........................^", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_struct: {'one': 1.0}}.single_struct", + container: "cel.expr.conformance.proto3", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "one" }, + value: { doubleValue: 1 }, + }, + ], + }, + }, + }, + ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n "one"~string:1~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)', + type: "map(string, dyn)", + }, + { + original: { + name: "field_read_proto3_empty", + expr: "TestAllTypes{single_struct: {}}.single_struct", + container: "cel.expr.conformance.proto3", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{\n single_struct:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{}~map(string, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)", + type: "map(string, dyn)", + }, + { + original: { + name: "field_read_proto3_unset", + description: "Not a wrapper type, so doesn't convert to null.", + expr: "TestAllTypes{}.single_struct", + container: "cel.expr.conformance.proto3", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_struct^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_struct~map(string, dyn)", + type: "map(string, dyn)", + }, + ], + }, + { + name: "value_null", + tests: [ + { + original: { + name: "literal", + expr: "Value{null_value: NullValue.NULL_VALUE}", + container: "google.protobuf", + value: { nullValue: null }, + }, + ast: "Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "literal_no_field_access", + expr: "Value{null_value: NullValue.NULL_VALUE}.null_value", + disableCheck: true, + container: "google.protobuf", + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "Value{\n null_value:NullValue^#*expr.Expr_IdentExpr#.NULL_VALUE^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.null_value^#*expr.Expr_SelectExpr#", + checkedAst: + "google.protobuf.Value{\n null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE\n}~dyn^google.protobuf.Value.null_value~dyn", + type: "dyn", + }, + { + original: { + name: "literal_unset", + expr: "google.protobuf.Value{}", + value: { nullValue: null }, + }, + ast: "google.protobuf.Value{}^#*expr.Expr_StructExpr#", + checkedAst: "google.protobuf.Value{}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Value" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Value", + value: null, + }, + }, + }, + }, + value: { nullValue: null }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~dyn^x", + type: "dyn", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_value: null}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: null, + }, + }, + }, + ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_value: null}.single_value", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_read_proto2_unset", + expr: "TestAllTypes{}.single_value", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_value: null}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: null, + }, + }, + }, + ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_value: null}.single_value", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_read_proto3_unset", + expr: "TestAllTypes{}.single_value", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + ], + }, + { + name: "value_number", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Value{number_value: 12.5}", + value: { doubleValue: 12.5 }, + }, + ast: "google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Value{number_value: 12.5}.number_value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.Value{\n number_value:12.5^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.number_value^#*expr.Expr_SelectExpr#", + checkedAst: + "google.protobuf.Value{\n number_value:12.5~double\n}~dyn^google.protobuf.Value.number_value~dyn", + type: "dyn", + }, + { + original: { + name: "literal_zero", + expr: "google.protobuf.Value{number_value: 0.0}", + value: { doubleValue: 0 }, + }, + ast: "google.protobuf.Value{\n number_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n number_value:0~double\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Value" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Value", + value: -26.375, + }, + }, + }, + }, + value: { doubleValue: -26.375 }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~dyn^x", + type: "dyn", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_value: 7e23}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: 7e23, + }, + }, + }, + ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_zero", + expr: "TestAllTypes{single_value: 0.0}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_value: 7e23}.single_value", + container: "cel.expr.conformance.proto2", + value: { doubleValue: 7e23 }, + }, + ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_value: 0.0}.single_value", + container: "cel.expr.conformance.proto2", + value: { doubleValue: 0 }, + }, + ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_value: 7e23}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: 7e23, + }, + }, + }, + ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_zero", + expr: "TestAllTypes{single_value: 0.0}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: 0, + }, + }, + }, + ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_value: 7e23}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 7e23 }, + }, + ast: "TestAllTypes{\n single_value:7e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:7e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_read_proto3_zero", + expr: "TestAllTypes{single_value: 0.0}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 0 }, + }, + ast: "TestAllTypes{\n single_value:0^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:0~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + ], + }, + { + name: "value_string", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Value{string_value: 'foo'}", + value: { stringValue: "foo" }, + }, + ast: 'google.protobuf.Value{\n string_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.Value{\n string_value:"foo"~string\n}~dyn^google.protobuf.Value', + type: "dyn", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Value{string_value: 'foo'}.string_value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.Value{\n string_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.string_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'google.protobuf.Value{\n string_value:"foo"~string\n}~dyn^google.protobuf.Value.string_value~dyn', + type: "dyn", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.Value{string_value: ''}", + value: { stringValue: "" }, + }, + ast: 'google.protobuf.Value{\n string_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.Value{\n string_value:""~string\n}~dyn^google.protobuf.Value', + type: "dyn", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Value" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Value", + value: "bar", + }, + }, + }, + }, + value: { stringValue: "bar" }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~dyn^x", + type: "dyn", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_value: 'baz'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: "baz", + }, + }, + }, + ast: 'TestAllTypes{\n single_value:"baz"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:"baz"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{single_value: ''}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: "", + }, + }, + }, + ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_value: 'bletch'}.single_value", + container: "cel.expr.conformance.proto2", + value: { stringValue: "bletch" }, + }, + ast: 'TestAllTypes{\n single_value:"bletch"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:"bletch"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_read_proto2_zero", + expr: "TestAllTypes{single_value: ''}.single_value", + container: "cel.expr.conformance.proto2", + value: { stringValue: "" }, + }, + ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_value: 'baz'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: "baz", + }, + }, + }, + ast: 'TestAllTypes{\n single_value:"baz"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:"baz"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{single_value: ''}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: "", + }, + }, + }, + ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_value: 'bletch'}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "bletch" }, + }, + ast: 'TestAllTypes{\n single_value:"bletch"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:"bletch"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_read_proto3_zero", + expr: "TestAllTypes{single_value: ''}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "" }, + }, + ast: 'TestAllTypes{\n single_value:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:""~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + ], + }, + { + name: "value_bool", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Value{bool_value: true}", + value: { boolValue: true }, + }, + ast: "google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Value{bool_value: true}.bool_value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.Value{\n bool_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.bool_value^#*expr.Expr_SelectExpr#", + checkedAst: + "google.protobuf.Value{\n bool_value:true~bool\n}~dyn^google.protobuf.Value.bool_value~dyn", + type: "dyn", + }, + { + original: { + name: "literal_false", + expr: "google.protobuf.Value{bool_value: false}", + value: { boolValue: false }, + }, + ast: "google.protobuf.Value{\n bool_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n bool_value:false~bool\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Value" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Value", + value: true, + }, + }, + }, + }, + value: { boolValue: true }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~dyn^x", + type: "dyn", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_value: true}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: true, + }, + }, + }, + ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_false", + expr: "TestAllTypes{single_value: false}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: false, + }, + }, + }, + ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_value: true}.single_value", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_read_proto2_false", + expr: "TestAllTypes{single_value: false}.single_value", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_value: true}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: true, + }, + }, + }, + ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_false", + expr: "TestAllTypes{single_value: false}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: false, + }, + }, + }, + ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_value: true}.single_value", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_read_proto3_false", + expr: "TestAllTypes{single_value: false}.single_value", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n single_value:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:false~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + ], + }, + { + name: "value_struct", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}", + value: { + mapValue: { + entries: [ + { key: { stringValue: "a" }, value: { doubleValue: 1 } }, + { + key: { stringValue: "b" }, + value: { stringValue: "two" }, + }, + ], + }, + }, + }, + ast: 'google.protobuf.Value{\n struct_value:{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.Value{\n struct_value:{\n "a"~string:1~double,\n "b"~string:"two"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value', + type: "dyn", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Value{struct_value: {'a': 1.0, 'b': 'two'}}.struct_value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.Value{\n struct_value:{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.struct_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'google.protobuf.Value{\n struct_value:{\n "a"~string:1~double,\n "b"~string:"two"~string\n }~map(string, dyn)\n}~dyn^google.protobuf.Value.struct_value~dyn', + type: "dyn", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.Value{struct_value: {}}", + value: { mapValue: {} }, + }, + ast: "google.protobuf.Value{\n struct_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n struct_value:{}~map(string, dyn)\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Value" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Value", + value: { x: null, y: false }, + }, + }, + }, + }, + value: { + mapValue: { + entries: [ + { key: { stringValue: "x" }, value: { nullValue: null } }, + { + key: { stringValue: "y" }, + value: { boolValue: false }, + }, + ], + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~dyn^x", + type: "dyn", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: { deux: 2, un: 1 }, + }, + }, + }, + ast: 'TestAllTypes{\n single_value:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{single_value: {}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: {}, + }, + }, + }, + ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_value: {'i': true}}.single_value", + container: "cel.expr.conformance.proto2", + value: { + mapValue: { + entries: [ + { key: { stringValue: "i" }, value: { boolValue: true } }, + ], + }, + }, + }, + ast: 'TestAllTypes{\n single_value:{\n "i"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:{\n "i"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_read_proto2_empty", + expr: "TestAllTypes{single_value: {}}.single_value", + container: "cel.expr.conformance.proto2", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_value: {'un': 1.0, 'deux': 2.0}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: { deux: 2, un: 1 }, + }, + }, + }, + ast: 'TestAllTypes{\n single_value:{\n "un"^#*expr.Constant_StringValue#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n "deux"^#*expr.Constant_StringValue#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n "un"~string:1~double,\n "deux"~string:2~double\n }~map(string, double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{single_value: {}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: {}, + }, + }, + }, + ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_value: {'i': true}}.single_value", + container: "cel.expr.conformance.proto3", + value: { + mapValue: { + entries: [ + { key: { stringValue: "i" }, value: { boolValue: true } }, + ], + }, + }, + }, + ast: 'TestAllTypes{\n single_value:{\n "i"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:{\n "i"~string:true~bool\n }~map(string, bool)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_read_proto3_empty", + expr: "TestAllTypes{single_value: {}}.single_value", + container: "cel.expr.conformance.proto3", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{\n single_value:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + ], + }, + { + name: "value_list", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Value{list_value: ['a', 3.0]}", + value: { + listValue: { + values: [{ stringValue: "a" }, { doubleValue: 3 }], + }, + }, + }, + ast: 'google.protobuf.Value{\n list_value:[\n "a"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.Value{\n list_value:[\n "a"~string,\n 3~double\n ]~list(dyn)\n}~dyn^google.protobuf.Value', + type: "dyn", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Value{list_value: []}.list_value", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: "google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.list_value^#*expr.Expr_SelectExpr#", + checkedAst: + "google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value.list_value~dyn", + type: "dyn", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.Value{list_value: []}", + value: { listValue: {} }, + }, + ast: "google.protobuf.Value{\n list_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "google.protobuf.Value{\n list_value:[]~list(dyn)\n}~dyn^google.protobuf.Value", + type: "dyn", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Value" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Value", + value: [1, true, "hi"], + }, + }, + }, + }, + value: { + listValue: { + values: [ + { doubleValue: 1 }, + { boolValue: true }, + { stringValue: "hi" }, + ], + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~dyn^x", + type: "dyn", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_value: ['un', 1.0]}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: ["un", 1], + }, + }, + }, + ast: 'TestAllTypes{\n single_value:[\n "un"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n "un"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_assign_proto2_empty", + expr: "TestAllTypes{single_value: []}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: [], + }, + }, + }, + ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_value: ['i', true]}.single_value", + container: "cel.expr.conformance.proto2", + value: { + listValue: { + values: [{ stringValue: "i" }, { boolValue: true }], + }, + }, + }, + ast: 'TestAllTypes{\n single_value:[\n "i"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:[\n "i"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_read_proto2_empty", + expr: "TestAllTypes{single_value: []}.single_value", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_value: ['un', 1.0]}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: ["un", 1], + }, + }, + }, + ast: 'TestAllTypes{\n single_value:[\n "un"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n "un"~string,\n 1~double\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_assign_proto3_empty", + expr: "TestAllTypes{single_value: []}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: [], + }, + }, + }, + ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_value: ['i', true]}.single_value", + container: "cel.expr.conformance.proto3", + value: { + listValue: { + values: [{ stringValue: "i" }, { boolValue: true }], + }, + }, + }, + ast: 'TestAllTypes{\n single_value:[\n "i"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:[\n "i"~string,\n true~bool\n ]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "field_read_proto3_empty", + expr: "TestAllTypes{single_value: []}.single_value", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{\n single_value:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + ], + }, + { + name: "any", + tests: [ + { + original: { + name: "literal", + expr: "google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 150, + }, + }, + }, + ast: 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\b\\x96\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\b\\x96\\x01"~bytes\n}~any^google.protobuf.Any', + type: "any", + }, + { + original: { + name: "literal_no_field_access", + expr: "google.protobuf.Any{type_url: 'type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes', value: b'\\x08\\x96\\x01'}.type_url", + disableCheck: true, + evalError: { errors: [{ message: "no_matching_overload" }] }, + }, + ast: 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n value:b"\\b\\x96\\x01"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.type_url^#*expr.Expr_SelectExpr#', + checkedAst: + 'google.protobuf.Any{\n type_url:"type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes"~string,\n value:b"\\b\\x96\\x01"~bytes\n}~any^google.protobuf.Any.type_url~dyn', + type: "dyn", + }, + { + original: { + name: "literal_empty", + expr: "google.protobuf.Any{}", + evalError: { errors: [{ message: "conversion" }] }, + }, + ast: "google.protobuf.Any{}^#*expr.Expr_StructExpr#", + checkedAst: "google.protobuf.Any{}~any^google.protobuf.Any", + type: "any", + }, + { + original: { + name: "var", + expr: "x", + typeEnv: [ + { + name: "x", + ident: { type: { messageType: "google.protobuf.Any" } }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Any", + value: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 150, + }, + }, + }, + }, + }, + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 150, + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#", + checkedAst: "x~any^x", + type: "any", + }, + { + original: { + name: "field_assign_proto2", + expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleAny: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 150, + }, + }, + }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "field_read_proto2", + expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 150, + }, + }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "field_assign_proto3", + expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleAny: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 150, + }, + }, + }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "field_read_proto3", + expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 150}}.single_any", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 150, + }, + }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:150^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:150~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + ], + }, + { + name: "complex", + tests: [ + { + original: { + name: "any_list_map", + expr: "TestAllTypes{single_any: [{'almost': 'done'}]}.single_any", + container: "cel.expr.conformance.proto3", + value: { + listValue: { + values: [ + { + mapValue: { + entries: [ + { + key: { stringValue: "almost" }, + value: { stringValue: "done" }, + }, + ], + }, + }, + ], + }, + }, + }, + ast: 'TestAllTypes{\n single_any:[\n {\n "almost"^#*expr.Constant_StringValue#:"done"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_any:[\n {\n "almost"~string:"done"~string\n }~map(string, string)\n ]~list(map(string, string))\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any', + type: "any", + }, + ], + }, + ], + }, + { + name: "encoders_ext", + suites: [ + { + name: "encode", + tests: [ + { + original: { + name: "hello", + expr: "base64.encode(b'hello')", + value: { stringValue: "aGVsbG8=" }, + }, + ast: 'base64^#*expr.Expr_IdentExpr#.encode(\n b"hello"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'base64.encode(\n b"hello"~bytes\n)~string^base64_encode_bytes', + type: "string", + }, + ], + }, + { + name: "decode", + tests: [ + { + original: { + name: "hello", + expr: "base64.decode('aGVsbG8=')", + value: { bytesValue: "aGVsbG8=" }, + }, + ast: 'base64^#*expr.Expr_IdentExpr#.decode(\n "aGVsbG8="^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'base64.decode(\n "aGVsbG8="~string\n)~bytes^base64_decode_string', + type: "bytes", + }, + { + original: { + name: "hello_without_padding", + expr: "base64.decode('aGVsbG8')", + value: { bytesValue: "aGVsbG8=" }, + }, + ast: 'base64^#*expr.Expr_IdentExpr#.decode(\n "aGVsbG8"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'base64.decode(\n "aGVsbG8"~string\n)~bytes^base64_decode_string', + type: "bytes", + }, + ], + }, + { + name: "round_trip", + tests: [ + { + original: { + name: "hello", + expr: "base64.decode(base64.encode(b'Hello World!'))", + value: { bytesValue: "SGVsbG8gV29ybGQh" }, + }, + ast: 'base64^#*expr.Expr_IdentExpr#.decode(\n base64^#*expr.Expr_IdentExpr#.encode(\n b"Hello World!"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'base64.decode(\n base64.encode(\n b"Hello World!"~bytes\n )~string^base64_encode_bytes\n)~bytes^base64_decode_string', + type: "bytes", + }, + ], + }, + ], + }, + { + name: "enums", + suites: [ + { + name: "legacy_proto2", + tests: [ + { + original: { + name: "literal_global", + expr: "GlobalEnum.GAZ", + container: "cel.expr.conformance.proto2", + value: { int64Value: "2" }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ", + type: "int", + }, + { + original: { + name: "literal_nested", + expr: "TestAllTypes.NestedEnum.BAR", + container: "cel.expr.conformance.proto2", + value: { int64Value: "1" }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", + type: "int", + }, + { + original: { + name: "literal_zero", + expr: "GlobalEnum.GOO", + container: "cel.expr.conformance.proto2", + value: { int64Value: "0" }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO", + type: "int", + }, + { + original: { + name: "comparison", + expr: "GlobalEnum.GAR == 1", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "arithmetic", + expr: "TestAllTypes.NestedEnum.BAR + 3", + container: "cel.expr.conformance.proto2", + value: { int64Value: "4" }, + }, + ast: "_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "type_global", + expr: "type(GlobalEnum.GOO)", + container: "cel.expr.conformance.proto2", + value: { typeValue: "int" }, + }, + ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "type_nested", + expr: "type(TestAllTypes.NestedEnum.BAZ)", + container: "cel.expr.conformance.proto2", + value: { typeValue: "int" }, + }, + ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "select_default", + expr: "TestAllTypes{}.standalone_enum", + container: "cel.expr.conformance.proto2", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int", + type: "int", + }, + { + original: { + name: "field_type", + expr: "type(TestAllTypes{}.standalone_enum)", + container: "cel.expr.conformance.proto2", + value: { typeValue: "int" }, + }, + ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "assign_standalone_name", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + standaloneEnum: "BAZ", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int", + expr: "TestAllTypes{standalone_enum: 1}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + standaloneEnum: "BAR", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int_too_big", + expr: "TestAllTypes{standalone_enum: 5000000000}", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int_too_neg", + expr: "TestAllTypes{standalone_enum: -7000000000}", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "access_repeated_enum", + expr: "TestAllTypes{}.repeated_nested_enum", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)", + type: "list(int)", + }, + { + original: { + name: "assign_repeated_enum", + expr: "TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + repeatedNestedEnum: ["FOO", "BAR"], + }, + }, + }, + ast: "TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "list_enum_as_list_int", + expr: "0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "enum_as_int", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list", + type: "bool", + }, + ], + }, + { + name: "legacy_proto3", + tests: [ + { + original: { + name: "literal_global", + expr: "GlobalEnum.GAZ", + container: "cel.expr.conformance.proto3", + value: { int64Value: "2" }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ", + type: "int", + }, + { + original: { + name: "literal_nested", + expr: "TestAllTypes.NestedEnum.BAR", + container: "cel.expr.conformance.proto3", + value: { int64Value: "1" }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR", + type: "int", + }, + { + original: { + name: "literal_zero", + expr: "GlobalEnum.GOO", + container: "cel.expr.conformance.proto3", + value: { int64Value: "0" }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO", + type: "int", + }, + { + original: { + name: "comparison", + expr: "GlobalEnum.GAR == 1", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "arithmetic", + expr: "TestAllTypes.NestedEnum.BAR + 3", + container: "cel.expr.conformance.proto3", + value: { int64Value: "4" }, + }, + ast: "_+_(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR,\n 3~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "type_global", + expr: "type(GlobalEnum.GOO)", + container: "cel.expr.conformance.proto3", + value: { typeValue: "int" }, + }, + ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "type_nested", + expr: "type(TestAllTypes.NestedEnum.BAZ)", + container: "cel.expr.conformance.proto3", + value: { typeValue: "int" }, + }, + ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "select_default", + expr: "TestAllTypes{}.standalone_enum", + container: "cel.expr.conformance.proto3", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int", + type: "int", + }, + { + original: { + name: "select", + expr: "x.standalone_enum", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + container: "cel.expr.conformance.proto3", + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: "BAZ", + }, + }, + }, + }, + value: { int64Value: "2" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", + type: "int", + }, + { + original: { + name: "select_big", + expr: "x.standalone_enum", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + container: "cel.expr.conformance.proto3", + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: 108, + }, + }, + }, + }, + value: { int64Value: "108" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", + type: "int", + }, + { + original: { + name: "select_neg", + expr: "x.standalone_enum", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + container: "cel.expr.conformance.proto3", + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: -3, + }, + }, + }, + }, + value: { int64Value: "-3" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", + type: "int", + }, + { + original: { + name: "field_type", + expr: "type(TestAllTypes{}.standalone_enum)", + container: "cel.expr.conformance.proto3", + value: { typeValue: "int" }, + }, + ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "assign_standalone_name", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: "BAZ", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int", + expr: "TestAllTypes{standalone_enum: 1}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: "BAR", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int_big", + expr: "TestAllTypes{standalone_enum: 99}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: 99, + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:99^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:99~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int_neg", + expr: "TestAllTypes{standalone_enum: -1}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: -1, + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int_too_big", + expr: "TestAllTypes{standalone_enum: 5000000000}", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes{\n standalone_enum:5000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:5000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int_too_neg", + expr: "TestAllTypes{standalone_enum: -7000000000}", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes{\n standalone_enum:-7000000000^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:-7000000000~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "access_repeated_enum", + expr: "TestAllTypes{}.repeated_nested_enum", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)", + type: "list(int)", + }, + { + original: { + name: "assign_repeated_enum", + expr: "TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + repeatedNestedEnum: ["FOO", "BAR"], + }, + }, + }, + ast: "TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "list_enum_as_list_int", + expr: "0 in TestAllTypes{ repeated_nested_enum: [ TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAR]}.repeated_nested_enum", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "@in(\n 0^#*expr.Constant_Int64Value#,\n TestAllTypes{\n repeated_nested_enum:[\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#,\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n 0~int,\n cel.expr.conformance.proto2.TestAllTypes{\n repeated_nested_enum:[\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n ]~list(int)\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_enum~list(int)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "enum_as_int", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum in [0]", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "@in(\n TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#,\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int,\n [\n 0~int\n ]~list(int)\n)~bool^in_list", + type: "bool", + }, + ], + }, + { + name: "strong_proto2", + tests: [ + { + original: { + name: "literal_global", + expr: "GlobalEnum.GAZ", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.GlobalEnum", + value: 2, + }, + }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ", + type: "int", + }, + { + original: { + name: "literal_nested", + expr: "TestAllTypes.NestedEnum.BAR", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + value: 1, + }, + }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", + type: "int", + }, + { + original: { + name: "literal_zero", + expr: "GlobalEnum.GOO", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { type: "cel.expr.conformance.proto2.GlobalEnum" }, + }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO", + type: "int", + }, + { + original: { + name: "comparison_true", + expr: "GlobalEnum.GAR == GlobalEnum.GAR", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "comparison_false", + expr: "GlobalEnum.GAR == GlobalEnum.GAZ", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.GlobalEnum.GAR~int^cel.expr.conformance.proto2.GlobalEnum.GAR,\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "type_global", + expr: "type(GlobalEnum.GOO)", + container: "cel.expr.conformance.proto2", + value: { typeValue: "cel.expr.conformance.proto2.GlobalEnum" }, + }, + ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto2.GlobalEnum.GOO~int^cel.expr.conformance.proto2.GlobalEnum.GOO\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "type_nested", + expr: "type(TestAllTypes.NestedEnum.BAZ)", + container: "cel.expr.conformance.proto2", + value: { + typeValue: + "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + }, + }, + ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "select_default", + expr: "TestAllTypes{}.standalone_enum", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int", + type: "int", + }, + { + original: { + name: "field_type", + expr: "type(TestAllTypes{}.standalone_enum)", + container: "cel.expr.conformance.proto2", + value: { + typeValue: + "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + }, + }, + ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~int\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "assign_standalone_name", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + standaloneEnum: "BAZ", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + standaloneEnum: "BAR", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + error: + "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^", + }, + { + original: { + name: "convert_symbol_to_int", + expr: "int(GlobalEnum.GAZ)", + container: "cel.expr.conformance.proto2", + value: { int64Value: "2" }, + }, + ast: "int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n cel.expr.conformance.proto2.GlobalEnum.GAZ~int^cel.expr.conformance.proto2.GlobalEnum.GAZ\n)~int^int64_to_int64", + type: "int", + }, + { + original: { + name: "convert_unnamed_to_int", + description: "Disable check - missing way to declare enums.", + expr: "int(x)", + disableCheck: true, + bindings: { + x: { + value: { + enumValue: { + type: "cel.expr.conformance.proto2.GlobalEnum", + value: 444, + }, + }, + }, + }, + value: { int64Value: "444" }, + }, + ast: "int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^", + }, + { + original: { + name: "convert_int_inrange", + expr: "TestAllTypes.NestedEnum(2)", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + value: 2, + }, + }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(2)\n | .......................^", + }, + { + original: { + name: "convert_int_big", + expr: "TestAllTypes.NestedEnum(20000)", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + value: 20000, + }, + }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(20000)\n | .......................^", + }, + { + original: { + name: "convert_int_neg", + expr: "GlobalEnum(-33)", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.GlobalEnum", + value: -33, + }, + }, + }, + ast: "GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto2')\n | GlobalEnum(-33)\n | ..........^", + }, + { + original: { + name: "convert_int_too_big", + expr: "TestAllTypes.NestedEnum(5000000000)", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^", + }, + { + original: { + name: "convert_int_too_neg", + expr: "TestAllTypes.NestedEnum(-7000000000)", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^", + }, + { + original: { + name: "convert_string", + expr: "TestAllTypes.NestedEnum('BAZ')", + container: "cel.expr.conformance.proto2", + value: { + enumValue: { + type: "cel.expr.conformance.proto2.TestAllTypes.NestedEnum", + value: 2, + }, + }, + }, + ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BAZ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^", + }, + { + original: { + name: "convert_string_bad", + expr: "TestAllTypes.NestedEnum('BLETCH')", + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "invalid" }] }, + }, + ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BLETCH"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto2')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^", + }, + ], + }, + { + name: "strong_proto3", + tests: [ + { + original: { + name: "literal_global", + expr: "GlobalEnum.GAZ", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.GlobalEnum", + value: 2, + }, + }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ", + type: "int", + }, + { + original: { + name: "literal_nested", + expr: "TestAllTypes.NestedEnum.BAR", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: 1, + }, + }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR", + type: "int", + }, + { + original: { + name: "literal_zero", + expr: "GlobalEnum.GOO", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { type: "cel.expr.conformance.proto3.GlobalEnum" }, + }, + }, + ast: "GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO", + type: "int", + }, + { + original: { + name: "comparison_true", + expr: "GlobalEnum.GAR == GlobalEnum.GAR", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "comparison_false", + expr: "GlobalEnum.GAR == GlobalEnum.GAZ", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "_==_(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAR^#*expr.Expr_SelectExpr#,\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.GlobalEnum.GAR~int^cel.expr.conformance.proto3.GlobalEnum.GAR,\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "type_global", + expr: "type(GlobalEnum.GOO)", + container: "cel.expr.conformance.proto3", + value: { typeValue: "cel.expr.conformance.proto3.GlobalEnum" }, + }, + ast: "type(\n GlobalEnum^#*expr.Expr_IdentExpr#.GOO^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto3.GlobalEnum.GOO~int^cel.expr.conformance.proto3.GlobalEnum.GOO\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "type_nested", + expr: "type(TestAllTypes.NestedEnum.BAZ)", + container: "cel.expr.conformance.proto3", + value: { + typeValue: + "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + }, + }, + ast: "type(\n TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "select_default", + expr: "TestAllTypes{}.standalone_enum", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int", + type: "int", + }, + { + original: { + name: "select", + expr: "x.standalone_enum", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + container: "cel.expr.conformance.proto3", + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: "BAZ", + }, + }, + }, + }, + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: 2, + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", + type: "int", + }, + { + original: { + name: "select_big", + expr: "x.standalone_enum", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + container: "cel.expr.conformance.proto3", + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: 108, + }, + }, + }, + }, + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: 108, + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", + type: "int", + }, + { + original: { + name: "select_neg", + expr: "x.standalone_enum", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + container: "cel.expr.conformance.proto3", + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: -3, + }, + }, + }, + }, + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: -3, + }, + }, + }, + ast: "x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int", + type: "int", + }, + { + original: { + name: "field_type", + expr: "type(TestAllTypes{}.standalone_enum)", + container: "cel.expr.conformance.proto3", + value: { + typeValue: + "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + }, + }, + ast: "type(\n TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "type(\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int\n)~type(int)^type", + type: "type(int)", + }, + { + original: { + name: "assign_standalone_name", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAZ}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: "BAZ", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "assign_standalone_int", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: "BAR", + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + error: + "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(1)}\n | .....................................................^", + }, + { + original: { + name: "assign_standalone_int_big", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: 99, + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 99^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + error: + "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(99)}\n | .....................................................^", + }, + { + original: { + name: "assign_standalone_int_neg", + expr: "TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: -1, + }, + }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + error: + "ERROR: \u003cinput\u003e:1:54: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes{standalone_enum: TestAllTypes.NestedEnum(-1)}\n | .....................................................^", + }, + { + original: { + name: "convert_symbol_to_int", + expr: "int(GlobalEnum.GAZ)", + container: "cel.expr.conformance.proto3", + value: { int64Value: "2" }, + }, + ast: "int(\n GlobalEnum^#*expr.Expr_IdentExpr#.GAZ^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ\n)~int^int64_to_int64", + type: "int", + }, + { + original: { + name: "convert_unnamed_to_int", + description: "Disable check - missing way to declare enums.", + expr: "int(x)", + disableCheck: true, + bindings: { + x: { + value: { + enumValue: { + type: "cel.expr.conformance.proto3.GlobalEnum", + value: 444, + }, + }, + }, + }, + value: { int64Value: "444" }, + }, + ast: "int(\n x^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:5: undeclared reference to 'x' (in container '')\n | int(x)\n | ....^", + }, + { + original: { + name: "convert_unnamed_to_int_select", + expr: "int(x.standalone_enum)", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + standaloneEnum: -987, + }, + }, + }, + }, + value: { int64Value: "-987" }, + }, + ast: "int(\n x^#*expr.Expr_IdentExpr#.standalone_enum^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n x~cel.expr.conformance.proto3.TestAllTypes^x.standalone_enum~int\n)~int^int64_to_int64", + type: "int", + }, + { + original: { + name: "convert_int_inrange", + expr: "TestAllTypes.NestedEnum(2)", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: 2, + }, + }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(2)\n | .......................^", + }, + { + original: { + name: "convert_int_big", + expr: "TestAllTypes.NestedEnum(20000)", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: 20000, + }, + }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 20000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(20000)\n | .......................^", + }, + { + original: { + name: "convert_int_neg", + expr: "GlobalEnum(-33)", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.GlobalEnum", + value: -33, + }, + }, + }, + ast: "GlobalEnum(\n -33^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:11: undeclared reference to 'GlobalEnum' (in container 'cel.expr.conformance.proto3')\n | GlobalEnum(-33)\n | ..........^", + }, + { + original: { + name: "convert_int_too_big", + expr: "TestAllTypes.NestedEnum(5000000000)", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(5000000000)\n | .......................^", + }, + { + original: { + name: "convert_int_too_neg", + expr: "TestAllTypes.NestedEnum(-7000000000)", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "range" }] }, + }, + ast: "TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n -7000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum(-7000000000)\n | .......................^", + }, + { + original: { + name: "convert_string", + expr: "TestAllTypes.NestedEnum('BAZ')", + container: "cel.expr.conformance.proto3", + value: { + enumValue: { + type: "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + value: 2, + }, + }, + }, + ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BAZ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BAZ')\n | .......................^", + }, + { + original: { + name: "convert_string_bad", + expr: "TestAllTypes.NestedEnum('BLETCH')", + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "invalid" }] }, + }, + ast: 'TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum(\n "BLETCH"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'NestedEnum' (in container 'cel.expr.conformance.proto3')\n | TestAllTypes.NestedEnum('BLETCH')\n | .......................^", + }, + ], + }, + ], + }, + { + name: "fields", + suites: [ + { + name: "map_fields", + tests: [ + { + original: { + name: "map_key_int64", + expr: "{0:1,2:2,5:true}[5]", + value: { boolValue: true }, + }, + ast: "_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:true~bool\n }~map(int, dyn),\n 5~int\n)~dyn^index_map", + type: "dyn", + }, + { + original: { + name: "map_key_uint64", + expr: "{0u:1u,2u:'happy',5u:3u}[2u]", + value: { stringValue: "happy" }, + }, + ast: '_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:"happy"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:"happy"~string,\n 5u~uint:3u~uint\n }~map(uint, dyn),\n 2u~uint\n)~dyn^index_map', + type: "dyn", + }, + { + original: { + name: "map_key_string", + expr: "{'name':100u}['name']", + value: { uint64Value: "100" }, + }, + ast: '_[_](\n {\n "name"^#*expr.Constant_StringValue#:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "name"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n "name"~string:100u~uint\n }~map(string, uint),\n "name"~string\n)~uint^index_map', + type: "uint", + }, + { + original: { + name: "map_key_bool", + expr: "{true:5}[true]", + value: { int64Value: "5" }, + }, + ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n true~bool:5~int\n }~map(bool, int),\n true~bool\n)~int^index_map", + type: "int", + }, + { + original: { + name: "map_key_mixed_type", + expr: "{true:1,2:2,5u:3}[true]", + value: { int64Value: "1" }, + }, + ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n true~bool:1~int,\n 2~int:2~int,\n 5u~uint:3~int\n }~map(dyn, int),\n true~bool\n)~int^index_map", + type: "int", + }, + { + original: { + name: "map_key_mixed_numbers_double_key", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[3.0]", + value: { doubleValue: 3 }, + }, + ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3~double\n)~double^index_map", + type: "double", + }, + { + original: { + name: "map_key_mixed_numbers_lossy_double_key", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[3.1]", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3.1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 3.1~double\n)~double^index_map", + type: "double", + }, + { + original: { + name: "map_key_mixed_numbers_uint_key", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[2u]", + value: { doubleValue: 2 }, + }, + ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 2u~uint\n)~double^index_map", + type: "double", + }, + { + original: { + name: "map_key_mixed_numbers_int_key", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[1]", + value: { doubleValue: 1 }, + }, + ast: "_[_](\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 1u~uint:1~double,\n 2~int:2~double,\n 3u~uint:3~double\n }~map(dyn, double),\n 1~int\n)~double^index_map", + type: "double", + }, + { + original: { + name: "map_field_access", + expr: "x.name", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "INT64" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "name" }, + value: { int64Value: "1024" }, + }, + ], + }, + }, + }, + }, + value: { int64Value: "1024" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#", + checkedAst: "x~map(string, int)^x.name~int", + type: "int", + }, + { + original: { + name: "map_no_such_key", + expr: "{0:1,2:2,5:3}[1]", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: "_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n)~int^index_map", + type: "int", + }, + { + original: { + name: "map_no_such_key_or_false", + expr: "dyn({0:1,2:2,5:3}[1]) || false", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: "_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "map_no_such_key_or_true", + expr: "dyn({0:1,2:2,5:3}[1]) || true", + value: { boolValue: true }, + }, + ast: "_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "map_no_such_key_and_false", + expr: "dyn({0:1,2:2,5:3}[1]) \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "map_no_such_key_and_true", + expr: "dyn({0:1,2:2,5:3}[1]) \u0026\u0026 true", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n 1~int\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "map_bad_key_type", + expr: "{0:1,2:2,5:3}[dyn(b'')]", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: '_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n)~int^index_map', + type: "int", + }, + { + original: { + name: "map_bad_key_type_or_false", + expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) || false", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: '_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or', + type: "bool", + }, + { + original: { + name: "map_bad_key_type_or_true", + expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) || true", + value: { boolValue: true }, + }, + ast: '_||_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_||_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or', + type: "bool", + }, + { + original: { + name: "map_bad_key_type_and_false", + expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and', + type: "bool", + }, + { + original: { + name: "map_bad_key_type_and_true", + expr: "dyn({0:1,2:2,5:3}[dyn(b'')]) \u0026\u0026 true", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n b""^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u0026\u0026_(\n dyn(\n _[_](\n {\n 0~int:1~int,\n 2~int:2~int,\n 5~int:3~int\n }~map(int, int),\n dyn(\n b""~bytes\n )~dyn^to_dyn\n )~int^index_map\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and', + type: "bool", + }, + { + original: { + name: "map_field_select_no_such_key", + expr: "x.name", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "holiday" }, + value: { stringValue: "field" }, + }, + ], + }, + }, + }, + }, + evalError: { errors: [{ message: "no such key: 'name'" }] }, + }, + ast: "x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#", + checkedAst: "x~map(string, string)^x.name~string", + type: "string", + }, + { + original: { + name: "map_field_select_no_such_key_or_false", + expr: "dyn(x.name) || false", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "holiday" }, + value: { stringValue: "field" }, + }, + ], + }, + }, + }, + }, + evalError: { errors: [{ message: "no such key: 'name'" }] }, + }, + ast: "_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "map_field_select_no_such_key_or_true", + expr: "dyn(x.name) || true", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "holiday" }, + value: { stringValue: "field" }, + }, + ], + }, + }, + }, + }, + value: { boolValue: true }, + }, + ast: "_||_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "map_field_select_no_such_key_and_false", + expr: "dyn(x.name) \u0026\u0026 false", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "holiday" }, + value: { stringValue: "field" }, + }, + ], + }, + }, + }, + }, + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "map_field_select_no_such_key_and_true", + expr: "dyn(x.name) \u0026\u0026 true", + typeEnv: [ + { + name: "x", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + x: { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "holiday" }, + value: { stringValue: "field" }, + }, + ], + }, + }, + }, + }, + evalError: { errors: [{ message: "no such key: 'name'" }] }, + }, + ast: "_\u0026\u0026_(\n dyn(\n x^#*expr.Expr_IdentExpr#.name^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n dyn(\n x~map(string, string)^x.name~string\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "map_value_null", + expr: "{true:null}[true]", + value: { nullValue: null }, + }, + ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n true~bool:null~null\n }~map(bool, null),\n true~bool\n)~null^index_map", + type: "null", + }, + { + original: { + name: "map_value_bool", + expr: "{27:false}[27]", + value: { boolValue: false }, + }, + ast: "_[_](\n {\n 27^#*expr.Constant_Int64Value#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 27^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 27~int:false~bool\n }~map(int, bool),\n 27~int\n)~bool^index_map", + type: "bool", + }, + { + original: { + name: "map_value_string", + expr: "{'n':'x'}['n']", + value: { stringValue: "x" }, + }, + ast: '_[_](\n {\n "n"^#*expr.Constant_StringValue#:"x"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "n"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n "n"~string:"x"~string\n }~map(string, string),\n "n"~string\n)~string^index_map', + type: "string", + }, + { + original: { + name: "map_value_float", + expr: "{3:15.15}[3]", + value: { doubleValue: 15.15 }, + }, + ast: "_[_](\n {\n 3^#*expr.Constant_Int64Value#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 3~int:15.15~double\n }~map(int, double),\n 3~int\n)~double^index_map", + type: "double", + }, + { + original: { + name: "map_value_uint64", + expr: "{0u:1u,2u:2u,5u:3u}[0u]", + value: { uint64Value: "1" }, + }, + ast: "_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2u^#*expr.Constant_Uint64Value#:2u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n 5u^#*expr.Constant_Uint64Value#:3u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 0u~uint:1u~uint,\n 2u~uint:2u~uint,\n 5u~uint:3u~uint\n }~map(uint, uint),\n 0u~uint\n)~uint^index_map", + type: "uint", + }, + { + original: { + name: "map_value_int64", + expr: "{true:1,false:2}[true]", + value: { int64Value: "1" }, + }, + ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n true~bool:1~int,\n false~bool:2~int\n }~map(bool, int),\n true~bool\n)~int^index_map", + type: "int", + }, + { + original: { + name: "map_value_bytes", + expr: "{0:b''}[0]", + value: { bytesValue: "" }, + }, + ast: '_[_](\n {\n 0^#*expr.Constant_Int64Value#:b""^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n 0~int:b""~bytes\n }~map(int, bytes),\n 0~int\n)~bytes^index_map', + type: "bytes", + }, + { + original: { + name: "map_value_list", + expr: "{0u:[1]}[0u]", + value: { listValue: { values: [{ int64Value: "1" }] } }, + }, + ast: "_[_](\n {\n 0u^#*expr.Constant_Uint64Value#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 0u~uint:[\n 1~int\n ]~list(int)\n }~map(uint, list(int)),\n 0u~uint\n)~list(int)^index_map", + type: "list(int)", + }, + { + original: { + name: "map_value_map", + expr: "{'map': {'k': 'v'}}['map']", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "k" }, + value: { stringValue: "v" }, + }, + ], + }, + }, + }, + ast: '_[_](\n {\n "map"^#*expr.Constant_StringValue#:{\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "map"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n "map"~string:{\n "k"~string:"v"~string\n }~map(string, string)\n }~map(string, map(string, string)),\n "map"~string\n)~map(string, string)^index_map', + type: "map(string, string)", + }, + { + original: { + name: "map_value_mix_type", + expr: "{'map': {'k': 'v'}, 'list': [1]}['map']", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "k" }, + value: { stringValue: "v" }, + }, + ], + }, + }, + }, + ast: '_[_](\n {\n "map"^#*expr.Constant_StringValue#:{\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#,\n "list"^#*expr.Constant_StringValue#:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "map"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n "map"~string:{\n "k"~string:"v"~string\n }~map(string, string),\n "list"~string:[\n 1~int\n ]~list(int)\n }~map(string, dyn),\n "map"~string\n)~dyn^index_map', + type: "dyn", + }, + ], + }, + { + name: "map_has", + tests: [ + { + original: { + name: "has", + expr: "has({'a': 1, 'b': 2}.a)", + value: { boolValue: true }, + }, + ast: '{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "a"~string:1~int,\n "b"~string:2~int\n}~map(string, int).a~test-only~~bool', + type: "bool", + }, + { + original: { + name: "has_not", + expr: "has({'a': 1, 'b': 2}.c)", + value: { boolValue: false }, + }, + ast: '{\n "a"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "b"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.c~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "a"~string:1~int,\n "b"~string:2~int\n}~map(string, int).c~test-only~~bool', + type: "bool", + }, + { + original: { + name: "has_empty", + expr: "has({}.a)", + value: { boolValue: false }, + }, + ast: "{}^#*expr.Expr_StructExpr#.a~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: "{}~map(dyn, dyn).a~test-only~~bool", + type: "bool", + }, + ], + }, + { + name: "quoted_map_fields", + tests: [ + { + original: { + name: "field_access_slash", + expr: "{'/api/v1': true, '/api/v2': false}.`/api/v1`", + value: { boolValue: true }, + }, + error: + "ERROR: field_access_slash:1:37: unsupported syntax: '`'\n | {'/api/v1': true, '/api/v2': false}.`/api/v1`\n | ....................................^", + }, + { + original: { + name: "field_access_dash", + expr: "{'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'", + value: { boolValue: true }, + }, + error: + "ERROR: field_access_dash:1:61: unsupported syntax: '`'\n | {'content-type': 'application/json', 'content-length': 145}.`content-type` == 'application/json'\n | ............................................................^", + }, + { + original: { + name: "field_access_dot", + expr: "{'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`", + value: { int64Value: "32" }, + }, + error: + "ERROR: field_access_dot:1:34: unsupported syntax: '`'\n | {'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`\n | .................................^", + }, + { + original: { + name: "has_field_slash", + expr: "has({'/api/v1': true, '/api/v2': false}.`/api/v3`)", + value: { boolValue: false }, + }, + error: + "ERROR: has_field_slash:1:41: unsupported syntax: '`'\n | has({'/api/v1': true, '/api/v2': false}.`/api/v3`)\n | ........................................^", + }, + { + original: { + name: "has_field_dash", + expr: "has({'content-type': 'application/json', 'content-length': 145}.`content-type`)", + value: { boolValue: true }, + }, + error: + "ERROR: has_field_dash:1:65: unsupported syntax: '`'\n | has({'content-type': 'application/json', 'content-length': 145}.`content-type`)\n | ................................................................^", + }, + { + original: { + name: "has_field_dot", + expr: "has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)", + value: { boolValue: true }, + }, + error: + "ERROR: has_field_dot:1:38: unsupported syntax: '`'\n | has({'foo.txt': 32, 'bar.csv': 1024}.`foo.txt`)\n | .....................................^", + }, + ], + }, + { + name: "qualified_identifier_resolution", + tests: [ + { + original: { + name: "qualified_ident", + expr: "a.b.c", + typeEnv: [ + { name: "a.b.c", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { "a.b.c": { value: { stringValue: "yeah" } } }, + value: { stringValue: "yeah" }, + }, + ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", + checkedAst: "a.b.c~string^a.b.c", + type: "string", + }, + { + original: { + name: "map_field_select", + expr: "a.b.c", + typeEnv: [ + { + name: "a.b", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + "a.b": { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "c" }, + value: { stringValue: "yeah" }, + }, + ], + }, + }, + }, + }, + value: { stringValue: "yeah" }, + }, + ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", + checkedAst: "a.b~map(string, string)^a.b.c~string", + type: "string", + }, + { + original: { + name: "qualified_identifier_resolution_unchecked", + description: + "namespace resolution should try to find the longest prefix for the evaluator.", + expr: "a.b.c", + disableCheck: true, + typeEnv: [ + { name: "a.b.c", ident: { type: { primitive: "STRING" } } }, + { + name: "a.b", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + "a.b": { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "c" }, + value: { stringValue: "oops" }, + }, + ], + }, + }, + }, + "a.b.c": { value: { stringValue: "yeah" } }, + }, + value: { stringValue: "yeah" }, + }, + ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", + checkedAst: "a.b.c~string^a.b.c", + type: "string", + }, + { + original: { + name: "list_field_select_unsupported", + expr: "a.b.pancakes", + disableCheck: true, + typeEnv: [ + { + name: "a.b", + ident: { + type: { listType: { elemType: { primitive: "STRING" } } }, + }, + }, + ], + bindings: { + "a.b": { + value: { + listValue: { values: [{ stringValue: "pancakes" }] }, + }, + }, + }, + evalError: { + errors: [ + { + message: + "type 'list_type:\u003celem_type:\u003cprimitive:STRING \u003e \u003e ' does not support field selection", + }, + ], + }, + }, + ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.pancakes^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:4: type 'list(string)' does not support field selection\n | a.b.pancakes\n | ...^", + }, + { + original: { + name: "int64_field_select_unsupported", + expr: "a.pancakes", + disableCheck: true, + typeEnv: [ + { name: "a", ident: { type: { primitive: "INT64" } } }, + ], + bindings: { a: { value: { int64Value: "15" } } }, + evalError: { + errors: [ + { + message: + "type 'int64_type' does not support field selection", + }, + ], + }, + }, + ast: "a^#*expr.Expr_IdentExpr#.pancakes^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:2: type 'int' does not support field selection\n | a.pancakes\n | .^", + }, + { + original: { + name: "ident_with_longest_prefix_check", + description: + "namespace resolution should try to find the longest prefix for the checker.", + expr: "a.b.c", + typeEnv: [ + { name: "a.b.c", ident: { type: { primitive: "STRING" } } }, + { + name: "a.b", + ident: { + type: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "STRING" }, + }, + }, + }, + }, + ], + bindings: { + "a.b": { + value: { + mapValue: { + entries: [ + { + key: { stringValue: "c" }, + value: { stringValue: "oops" }, + }, + ], + }, + }, + }, + "a.b.c": { value: { stringValue: "yeah" } }, + }, + value: { stringValue: "yeah" }, + }, + ast: "a^#*expr.Expr_IdentExpr#.b^#*expr.Expr_SelectExpr#.c^#*expr.Expr_SelectExpr#", + checkedAst: "a.b.c~string^a.b.c", + type: "string", + }, + { + original: { + name: "map_key_float", + description: "map should not support float as the key.", + expr: "{3.3:15.15, 1.0: 5}[1.0]", + disableCheck: true, + evalError: { errors: [{ message: "unsupported key type" }] }, + }, + ast: "_[_](\n {\n 3.3^#*expr.Constant_DoubleValue#:15.15^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_DoubleValue#:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 3.3~double:15.15~double,\n 1~double:5~int\n }~map(double, dyn),\n 1~double\n)~dyn^index_map", + type: "dyn", + }, + { + original: { + name: "map_key_null", + description: "map should not support null as the key.", + expr: "{null:false}[null]", + disableCheck: true, + evalError: { errors: [{ message: "unsupported key type" }] }, + }, + ast: "_[_](\n {\n null^#*expr.Constant_NullValue#:false^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n null~null:false~bool\n }~map(null, bool),\n null~null\n)~bool^index_map", + type: "bool", + }, + { + original: { + name: "map_value_repeat_key", + description: "map should not support repeated key.", + expr: "{true:1,false:2,true:3}[true]", + evalError: { + errors: [{ message: "Failed with repeated key" }], + }, + }, + ast: "_[_](\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n false^#*expr.Constant_BoolValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n true~bool:1~int,\n false~bool:2~int,\n true~bool:3~int\n }~map(bool, int),\n true~bool\n)~int^index_map", + type: "int", + }, + { + original: { + name: "map_value_repeat_key_heterogeneous", + description: "map should not support repeated key.", + expr: "{0: 1, 0u: 2}[0.0]", + evalError: { + errors: [{ message: "Failed with repeated key" }], + }, + }, + ast: "_[_](\n {\n 0^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 0u^#*expr.Constant_Uint64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n {\n 0~int:1~int,\n 0u~uint:2~int\n }~map(dyn, int),\n 0~double\n)~int^index_map", + type: "int", + }, + ], + }, + { + name: "in", + tests: [ + { + original: { + name: "empty", + expr: "7 in {}", + value: { boolValue: false }, + }, + ast: "@in(\n 7^#*expr.Constant_Int64Value#,\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: "@in(\n 7~int,\n {}~map(int, dyn)\n)~bool^in_map", + type: "bool", + }, + { + original: { + name: "singleton", + expr: "true in {true: 1}", + value: { boolValue: true }, + }, + ast: "@in(\n true^#*expr.Constant_BoolValue#,\n {\n true^#*expr.Constant_BoolValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n true~bool,\n {\n true~bool:1~int\n }~map(bool, int)\n)~bool^in_map", + type: "bool", + }, + { + original: { + name: "present", + expr: "'George' in {'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}", + value: { boolValue: true }, + }, + ast: '@in(\n "George"^#*expr.Constant_StringValue#,\n {\n "John"^#*expr.Constant_StringValue#:"smart"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Paul"^#*expr.Constant_StringValue#:"cute"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "George"^#*expr.Constant_StringValue#:"quiet"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Ringo"^#*expr.Constant_StringValue#:"funny"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "George"~string,\n {\n "John"~string:"smart"~string,\n "Paul"~string:"cute"~string,\n "George"~string:"quiet"~string,\n "Ringo"~string:"funny"~string\n }~map(string, string)\n)~bool^in_map', + type: "bool", + }, + { + original: { + name: "absent", + expr: "'spider' in {'ant': 6, 'fly': 6, 'centipede': 100}", + value: { boolValue: false }, + }, + ast: '@in(\n "spider"^#*expr.Constant_StringValue#,\n {\n "ant"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "fly"^#*expr.Constant_StringValue#:6^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "centipede"^#*expr.Constant_StringValue#:100^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "spider"~string,\n {\n "ant"~string:6~int,\n "fly"~string:6~int,\n "centipede"~string:100~int\n }~map(string, int)\n)~bool^in_map', + type: "bool", + }, + { + original: { + name: "mixed_numbers_and_keys_present", + expr: "3.0 in {1: 1, 2: 2, 3u: 3} \u0026\u0026 2u in {1u: 1, 2: 2} \u0026\u0026 1 in {1u: 1, 2: 2}", + value: { boolValue: true }, + }, + ast: "_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 2u^#*expr.Constant_Uint64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n @in(\n 1^#*expr.Constant_Int64Value#,\n {\n 1u^#*expr.Constant_Uint64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n _\u0026\u0026_(\n @in(\n 3~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n )~bool^in_map,\n @in(\n 2u~uint,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n )~bool^logical_and,\n @in(\n 1~int,\n {\n 1u~uint:1~int,\n 2~int:2~int\n }~map(dyn, int)\n )~bool^in_map\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "mixed_numbers_and_keys_absent", + expr: "3.1 in {1: 1, 2: 2, 3u: 3}", + value: { boolValue: false }, + }, + ast: "@in(\n 3.1^#*expr.Constant_DoubleValue#,\n {\n 1^#*expr.Constant_Int64Value#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 3u^#*expr.Constant_Uint64Value#:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n 3.1~double,\n {\n 1~int:1~int,\n 2~int:2~int,\n 3u~uint:3~int\n }~map(dyn, int)\n)~bool^in_map", + type: "bool", + }, + ], + }, + ], + }, + { + name: "fp_math", + suites: [ + { + name: "fp_math", + tests: [ + { + original: { + name: "add_positive_positive", + expr: "4.25 + 15.25", + value: { doubleValue: 19.5 }, + }, + ast: "_+_(\n 4.25^#*expr.Constant_DoubleValue#,\n 15.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n 4.25~double,\n 15.25~double\n)~double^add_double", + type: "double", + }, + { + original: { + name: "add_positive_negative", + expr: "17.75 + (-7.75)", + value: { doubleValue: 10 }, + }, + ast: "_+_(\n 17.75^#*expr.Constant_DoubleValue#,\n -7.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n 17.75~double,\n -7.75~double\n)~double^add_double", + type: "double", + }, + { + original: { + name: "add_negative_negative", + expr: "-4.125 + (-2.125)", + value: { doubleValue: -6.25 }, + }, + ast: "_+_(\n -4.125^#*expr.Constant_DoubleValue#,\n -2.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n -4.125~double,\n -2.125~double\n)~double^add_double", + type: "double", + }, + { + original: { + name: "sub_positive_positive", + expr: "42.0 - 12.0", + value: { doubleValue: 30 }, + }, + ast: "_-_(\n 42^#*expr.Constant_DoubleValue#,\n 12^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_-_(\n 42~double,\n 12~double\n)~double^subtract_double", + type: "double", + }, + { + original: { + name: "sub_positive_negative", + expr: "42.875 - (-22.0)", + value: { doubleValue: 64.875 }, + }, + ast: "_-_(\n 42.875^#*expr.Constant_DoubleValue#,\n -22^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_-_(\n 42.875~double,\n -22~double\n)~double^subtract_double", + type: "double", + }, + { + original: { + name: "sub_negative_negative", + expr: "-4.875 - (-0.125)", + value: { doubleValue: -4.75 }, + }, + ast: "_-_(\n -4.875^#*expr.Constant_DoubleValue#,\n -0.125^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_-_(\n -4.875~double,\n -0.125~double\n)~double^subtract_double", + type: "double", + }, + { + original: { + name: "multiply_positive_positive", + expr: "42.5 * 0.2", + value: { doubleValue: 8.5 }, + }, + ast: "_*_(\n 42.5^#*expr.Constant_DoubleValue#,\n 0.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 42.5~double,\n 0.2~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "multiply_positive_negative", + expr: "40.75 * (-2.25)", + value: { doubleValue: -91.6875 }, + }, + ast: "_*_(\n 40.75^#*expr.Constant_DoubleValue#,\n -2.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 40.75~double,\n -2.25~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "multiply_negative_negative", + expr: "-3.0 * (-2.5)", + value: { doubleValue: 7.5 }, + }, + ast: "_*_(\n -3^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n -3~double,\n -2.5~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "divide_positive_positive", + expr: "0.0625 / 0.002", + value: { doubleValue: 31.25 }, + }, + ast: "_/_(\n 0.0625^#*expr.Constant_DoubleValue#,\n 0.002^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n 0.0625~double,\n 0.002~double\n)~double^divide_double", + type: "double", + }, + { + original: { + name: "divide_positive_negative", + expr: "-2.0 / 2.0", + value: { doubleValue: -1 }, + }, + ast: "_/_(\n -2^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n -2~double,\n 2~double\n)~double^divide_double", + type: "double", + }, + { + original: { + name: "divide_negative_negative", + expr: "-8.875 / (-0.0625)", + value: { doubleValue: 142 }, + }, + ast: "_/_(\n -8.875^#*expr.Constant_DoubleValue#,\n -0.0625^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n -8.875~double,\n -0.0625~double\n)~double^divide_double", + type: "double", + }, + { + original: { + name: "mod_not_support", + expr: "47.5 % 5.5", + disableCheck: true, + evalError: { + errors: [ + { + message: + "found no matching overload for '_%_' applied to '(double, double)'", + }, + ], + }, + }, + ast: "_%_(\n 47.5^#*expr.Constant_DoubleValue#,\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:6: found no matching overload for '_%_' applied to '(double, double)'\n | 47.5 % 5.5\n | .....^", + }, + { + original: { + name: "negative", + expr: "-(4.5)", + value: { doubleValue: -4.5 }, + }, + ast: "-_(\n 4.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n 4.5~double\n)~double^negate_double", + type: "double", + }, + { + original: { + name: "double_negative", + expr: "-(-1.25)", + value: { doubleValue: 1.25 }, + }, + ast: "-_(\n -1.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n -1.25~double\n)~double^negate_double", + type: "double", + }, + { + original: { + name: "negative_zero", + expr: "-(0.0)", + value: { doubleValue: 0 }, + }, + ast: "-_(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n 0~double\n)~double^negate_double", + type: "double", + }, + { + original: { + name: "divide_zero", + expr: "15.75 / 0.0", + value: { doubleValue: "Infinity" }, + }, + ast: "_/_(\n 15.75^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n 15.75~double,\n 0~double\n)~double^divide_double", + type: "double", + }, + { + original: { + name: "multiply_zero", + expr: "15.36 * 0.0", + value: { doubleValue: 0 }, + }, + ast: "_*_(\n 15.36^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 15.36~double,\n 0~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "add_left_identity", + expr: "0.0 + 1.75", + value: { doubleValue: 1.75 }, + }, + ast: "_+_(\n 0^#*expr.Constant_DoubleValue#,\n 1.75^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n 0~double,\n 1.75~double\n)~double^add_double", + type: "double", + }, + { + original: { + name: "add_right_identity", + expr: " 2.5 + 0.0", + value: { doubleValue: 2.5 }, + }, + ast: "_+_(\n 2.5^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n 2.5~double,\n 0~double\n)~double^add_double", + type: "double", + }, + { + original: { + name: "add_commutative", + expr: "7.5 + 1.5 == 1.5 + 7.5", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n 7.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 7.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n 7.5~double,\n 1.5~double\n )~double^add_double,\n _+_(\n 1.5~double,\n 7.5~double\n )~double^add_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "add_associative", + expr: "5.625 + (15.75 + 2.0) == (5.625 + 15.75) + 2.0", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n _+_(\n 15.75^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5.625^#*expr.Constant_DoubleValue#,\n 15.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n 5.625~double,\n _+_(\n 15.75~double,\n 2~double\n )~double^add_double\n )~double^add_double,\n _+_(\n _+_(\n 5.625~double,\n 15.75~double\n )~double^add_double,\n 2~double\n )~double^add_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "mul_left_identity", + expr: "1.0 * 45.25", + value: { doubleValue: 45.25 }, + }, + ast: "_*_(\n 1^#*expr.Constant_DoubleValue#,\n 45.25^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 1~double,\n 45.25~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "mul_right_identity", + expr: "-25.25 * 1.0", + value: { doubleValue: -25.25 }, + }, + ast: "_*_(\n -25.25^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n -25.25~double,\n 1~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "mul_commutative", + expr: "1.5 * 25.875 == 25.875 * 1.5", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 25.875^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25.875^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 1.5~double,\n 25.875~double\n )~double^multiply_double,\n _*_(\n 25.875~double,\n 1.5~double\n )~double^multiply_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "mul_associative", + expr: "1.5 * (23.625 * 0.75) == (1.5 * 23.625) * 0.75", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n _*_(\n 23.625^#*expr.Constant_DoubleValue#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 1.5^#*expr.Constant_DoubleValue#,\n 23.625^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.75^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 1.5~double,\n _*_(\n 23.625~double,\n 0.75~double\n )~double^multiply_double\n )~double^multiply_double,\n _*_(\n _*_(\n 1.5~double,\n 23.625~double\n )~double^multiply_double,\n 0.75~double\n )~double^multiply_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "add_mul_distribute", + expr: "5.75 * (1.5 + 2.5) == 5.75 * 1.5 + 5.75 * 2.5", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n _+_(\n 1.5^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5.75^#*expr.Constant_DoubleValue#,\n 2.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 5.75~double,\n _+_(\n 1.5~double,\n 2.5~double\n )~double^add_double\n )~double^multiply_double,\n _+_(\n _*_(\n 5.75~double,\n 1.5~double\n )~double^multiply_double,\n _*_(\n 5.75~double,\n 2.5~double\n )~double^multiply_double\n )~double^add_double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "fp_overflow_positive", + description: "DBL_MAX(2^1023) times two", + expr: "2.0 * 8.988466e+307 ", + value: { doubleValue: "Infinity" }, + }, + ast: "_*_(\n 2^#*expr.Constant_DoubleValue#,\n 8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 2~double,\n 8.988466e+307~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "fp_overflow_negative", + description: "-DBL_MAX(-2^1023) times two", + expr: "2.0 * -8.988466e+307 ", + value: { doubleValue: "-Infinity" }, + }, + ast: "_*_(\n 2^#*expr.Constant_DoubleValue#,\n -8.988466e+307^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 2~double,\n -8.988466e+307~double\n)~double^multiply_double", + type: "double", + }, + { + original: { + name: "fp_underflow", + description: "DBL_MIN(2^-1074) divided by two", + expr: "1e-324 / 2.0", + value: { doubleValue: 0 }, + }, + ast: "_/_(\n 0^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n 0~double,\n 2~double\n)~double^divide_double", + type: "double", + }, + ], + }, + ], + }, + { + name: "integer_math", + suites: [ + { + name: "int64_math", + tests: [ + { + original: { + name: "add_positive_positive", + expr: "40 + 2", + value: { int64Value: "42" }, + }, + ast: "_+_(\n 40^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 40~int,\n 2~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "add_positive_negative", + expr: "42 + (-7)", + value: { int64Value: "35" }, + }, + ast: "_+_(\n 42^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 42~int,\n -7~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "add_negative_negative", + expr: "-4 + (-2)", + value: { int64Value: "-6" }, + }, + ast: "_+_(\n -4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n -4~int,\n -2~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "sub_positive_positive", + expr: "42 - 12", + value: { int64Value: "30" }, + }, + ast: "_-_(\n 42^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_-_(\n 42~int,\n 12~int\n)~int^subtract_int64", + type: "int", + }, + { + original: { + name: "sub_positive_negative", + expr: "42 - (-22)", + value: { int64Value: "64" }, + }, + ast: "_-_(\n 42^#*expr.Constant_Int64Value#,\n -22^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_-_(\n 42~int,\n -22~int\n)~int^subtract_int64", + type: "int", + }, + { + original: { + name: "sub_negative_negative", + expr: "-42 - (-12)", + value: { int64Value: "-30" }, + }, + ast: "_-_(\n -42^#*expr.Constant_Int64Value#,\n -12^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_-_(\n -42~int,\n -12~int\n)~int^subtract_int64", + type: "int", + }, + { + original: { + name: "multiply_positive_positive", + expr: "42 * 2", + value: { int64Value: "84" }, + }, + ast: "_*_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_*_(\n 42~int,\n 2~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "multiply_positive_negative", + expr: "40 * (-2)", + value: { int64Value: "-80" }, + }, + ast: "_*_(\n 40^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_*_(\n 40~int,\n -2~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "multiply_negative_negative", + expr: "-30 * (-2)", + value: { int64Value: "60" }, + }, + ast: "_*_(\n -30^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_*_(\n -30~int,\n -2~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "divide_positive_positive", + expr: "42 / 2", + value: { int64Value: "21" }, + }, + ast: "_/_(\n 42^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n 42~int,\n 2~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "divide_positive_negative", + expr: "-20 / 2", + value: { int64Value: "-10" }, + }, + ast: "_/_(\n -20^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n -20~int,\n 2~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "divide_negative_negative", + expr: "-80 / (-2)", + value: { int64Value: "40" }, + }, + ast: "_/_(\n -80^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n -80~int,\n -2~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "mod_positive_positive", + expr: "47 % 5", + value: { int64Value: "2" }, + }, + ast: "_%_(\n 47^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n 47~int,\n 5~int\n)~int^modulo_int64", + type: "int", + }, + { + original: { + name: "mod_positive_negative", + expr: "43 % (-5)", + value: { int64Value: "3" }, + }, + ast: "_%_(\n 43^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n 43~int,\n -5~int\n)~int^modulo_int64", + type: "int", + }, + { + original: { + name: "mod_negative_negative", + expr: "-42 % (-5)", + value: { int64Value: "-2" }, + }, + ast: "_%_(\n -42^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n -42~int,\n -5~int\n)~int^modulo_int64", + type: "int", + }, + { + original: { + name: "mod_negative_positive", + expr: "-3 % 5", + value: { int64Value: "-3" }, + }, + ast: "_%_(\n -3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n -3~int,\n 5~int\n)~int^modulo_int64", + type: "int", + }, + { + original: { + name: "unary_minus_pos", + expr: "-(42)", + value: { int64Value: "-42" }, + }, + ast: "-_(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n 42~int\n)~int^negate_int64", + type: "int", + }, + { + original: { + name: "unary_minus_neg", + expr: "-(-42)", + value: { int64Value: "42" }, + }, + ast: "-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n -42~int\n)~int^negate_int64", + type: "int", + }, + { + original: { + name: "unary_minus_no_overload", + expr: "-(42u)", + disableCheck: true, + evalError: { errors: [{ message: "no_such_overload" }] }, + }, + ast: "-_(\n 42u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(42u)\n | ^", + }, + { + original: { + name: "unary_minus_not_bool", + expr: "-false", + disableCheck: true, + evalError: { errors: [{ message: "no_such_overload" }] }, + }, + ast: "-_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(bool)'\n | -false\n | ^", + }, + { + original: { + name: "mod_zero", + expr: "34 % 0", + evalError: { errors: [{ message: "modulus by zero" }] }, + }, + ast: "_%_(\n 34^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n 34~int,\n 0~int\n)~int^modulo_int64", + type: "int", + }, + { + original: { + name: "negative_zero", + expr: "-(0)", + value: { int64Value: "0" }, + }, + ast: "-_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n 0~int\n)~int^negate_int64", + type: "int", + }, + { + original: { + name: "double_negative", + expr: "-(-42)", + value: { int64Value: "42" }, + }, + ast: "-_(\n -42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n -42~int\n)~int^negate_int64", + type: "int", + }, + { + original: { + name: "divide_zero", + expr: "15 / 0", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "_/_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n 15~int,\n 0~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "multiply_zero", + expr: "15 * 0", + value: { int64Value: "0" }, + }, + ast: "_*_(\n 15^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_*_(\n 15~int,\n 0~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "add_left_identity", + expr: "0 + 17", + value: { int64Value: "17" }, + }, + ast: "_+_(\n 0^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 0~int,\n 17~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "add_right_identity", + expr: " 29 + 0", + value: { int64Value: "29" }, + }, + ast: "_+_(\n 29^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 29~int,\n 0~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "add_commutative", + expr: "75 + 15 == 15 + 75", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n 75^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 75^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n 75~int,\n 15~int\n )~int^add_int64,\n _+_(\n 15~int,\n 75~int\n )~int^add_int64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "add_associative", + expr: "5 + (15 + 20) == (5 + 15) + 20", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n 5~int,\n _+_(\n 15~int,\n 20~int\n )~int^add_int64\n )~int^add_int64,\n _+_(\n _+_(\n 5~int,\n 15~int\n )~int^add_int64,\n 20~int\n )~int^add_int64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "mul_left_identity", + expr: "1 * 45", + value: { int64Value: "45" }, + }, + ast: "_*_(\n 1^#*expr.Constant_Int64Value#,\n 45^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_*_(\n 1~int,\n 45~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "mul_right_identity", + expr: "-25 * 1", + value: { int64Value: "-25" }, + }, + ast: "_*_(\n -25^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_*_(\n -25~int,\n 1~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "mul_commutative", + expr: "15 * 25 == 25 * 15", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 15~int,\n 25~int\n )~int^multiply_int64,\n _*_(\n 25~int,\n 15~int\n )~int^multiply_int64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "mul_associative", + expr: "15 * (23 * 88) == (15 * 23) * 88", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n _*_(\n 23^#*expr.Constant_Int64Value#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 88^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 15~int,\n _*_(\n 23~int,\n 88~int\n )~int^multiply_int64\n )~int^multiply_int64,\n _*_(\n _*_(\n 15~int,\n 23~int\n )~int^multiply_int64,\n 88~int\n )~int^multiply_int64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "add_mul_distribute", + expr: "5 * (15 + 25) == 5 * 15 + 5 * 25", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n _+_(\n 15^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 5~int,\n _+_(\n 15~int,\n 25~int\n )~int^add_int64\n )~int^multiply_int64,\n _+_(\n _*_(\n 5~int,\n 15~int\n )~int^multiply_int64,\n _*_(\n 5~int,\n 25~int\n )~int^multiply_int64\n )~int^add_int64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "int64_overflow_positive", + description: "LLONG_MAX plus one.", + expr: "9223372036854775807 + 1", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_+_(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n 9223372036854775807~int,\n 1~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "int64_overflow_negative", + description: "LLONG_MIN minus one.", + expr: "-9223372036854775808 - 1", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_-_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_-_(\n -9223372036854775808~int,\n 1~int\n)~int^subtract_int64", + type: "int", + }, + { + original: { + name: "int64_overflow_add_negative", + description: "negative overflow via addition", + expr: "-9223372036854775808 + (-1)", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_+_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n -9223372036854775808~int,\n -1~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "int64_overflow_sub_positive", + description: "positive overflow via subtraction", + expr: "1 - (-9223372036854775807)", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_-_(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_-_(\n 1~int,\n -9223372036854775807~int\n)~int^subtract_int64", + type: "int", + }, + { + original: { + name: "int64_min_negate", + description: "Negated LLONG_MIN is not representable.", + expr: "-(-9223372036854775808)", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "-_(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "-_(\n -9223372036854775808~int\n)~int^negate_int64", + type: "int", + }, + { + original: { + name: "int64_min_negate_mul", + description: "Negate LLONG_MIN via multiplication", + expr: "(-9223372036854775808) * -1", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_*_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n -9223372036854775808~int,\n -1~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "int64_min_negate_div", + description: "Negate LLONG_MIN via division.", + expr: "(-9223372036854775808)/-1", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_/_(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n -9223372036854775808~int,\n -1~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "int64_overflow_mul_positive", + description: "Overflow via multiplication.", + expr: "5000000000 * 5000000000", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_*_(\n 5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 5000000000~int,\n 5000000000~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "int64_overflow_mul_negative", + description: "Overflow via multiplication.", + expr: "(-5000000000) * 5000000000", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_*_(\n -5000000000^#*expr.Constant_Int64Value#,\n 5000000000^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n -5000000000~int,\n 5000000000~int\n)~int^multiply_int64", + type: "int", + }, + { + original: { + name: "uint64_overflow_positive", + description: "ULLONG_MAX plus one.", + expr: "18446744073709551615u + 1u", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_+_(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^add_uint64", + type: "uint", + }, + { + original: { + name: "uint64_overflow_negative", + description: "zero minus one.", + expr: "0u - 1u", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_-_(\n 0u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_-_(\n 0u~uint,\n 1u~uint\n)~uint^subtract_uint64", + type: "uint", + }, + { + original: { + name: "uint64_overflow_mul_positive", + description: "Overflow via multiplication.", + expr: "5000000000u * 5000000000u", + evalError: { + errors: [{ message: "return error for overflow" }], + }, + }, + ast: "_*_(\n 5000000000u^#*expr.Constant_Uint64Value#,\n 5000000000u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 5000000000u~uint,\n 5000000000u~uint\n)~uint^multiply_uint64", + type: "uint", + }, + ], + }, + { + name: "uint64_math", + tests: [ + { + original: { + name: "add", + expr: "42u + 2u", + value: { uint64Value: "44" }, + }, + ast: "_+_(\n 42u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 42u~uint,\n 2u~uint\n)~uint^add_uint64", + type: "uint", + }, + { + original: { + name: "sub", + expr: "42u - 12u", + value: { uint64Value: "30" }, + }, + ast: "_-_(\n 42u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_-_(\n 42u~uint,\n 12u~uint\n)~uint^subtract_uint64", + type: "uint", + }, + { + original: { + name: "multiply", + expr: "40u * 2u", + value: { uint64Value: "80" }, + }, + ast: "_*_(\n 40u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 40u~uint,\n 2u~uint\n)~uint^multiply_uint64", + type: "uint", + }, + { + original: { + name: "divide", + expr: "60u / 2u", + value: { uint64Value: "30" }, + }, + ast: "_/_(\n 60u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n 60u~uint,\n 2u~uint\n)~uint^divide_uint64", + type: "uint", + }, + { + original: { + name: "mod", + expr: "42u % 5u", + value: { uint64Value: "2" }, + }, + ast: "_%_(\n 42u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n 42u~uint,\n 5u~uint\n)~uint^modulo_uint64", + type: "uint", + }, + { + original: { + name: "negative_no_overload", + expr: "-(5u)", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "-_(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: found no matching overload for '-_' applied to '(uint)'\n | -(5u)\n | ^", + }, + { + original: { + name: "mod_zero", + expr: "34u % 0u", + evalError: { errors: [{ message: "modulus by zero" }] }, + }, + ast: "_%_(\n 34u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_%_(\n 34u~uint,\n 0u~uint\n)~uint^modulo_uint64", + type: "uint", + }, + { + original: { + name: "divide_zero", + expr: "15u / 0u", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "_/_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n 15u~uint,\n 0u~uint\n)~uint^divide_uint64", + type: "uint", + }, + { + original: { + name: "multiply_zero", + expr: "15u * 0u", + value: { uint64Value: "0" }, + }, + ast: "_*_(\n 15u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 15u~uint,\n 0u~uint\n)~uint^multiply_uint64", + type: "uint", + }, + { + original: { + name: "add_left_identity", + expr: "0u + 17u", + value: { uint64Value: "17" }, + }, + ast: "_+_(\n 0u^#*expr.Constant_Uint64Value#,\n 17u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 0u~uint,\n 17u~uint\n)~uint^add_uint64", + type: "uint", + }, + { + original: { + name: "add_right_identity", + expr: " 29u + 0u", + value: { uint64Value: "29" }, + }, + ast: "_+_(\n 29u^#*expr.Constant_Uint64Value#,\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_+_(\n 29u~uint,\n 0u~uint\n)~uint^add_uint64", + type: "uint", + }, + { + original: { + name: "add_commutative", + expr: "75u + 15u == 15u + 75u", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n 75u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 75u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n 75u~uint,\n 15u~uint\n )~uint^add_uint64,\n _+_(\n 15u~uint,\n 75u~uint\n )~uint^add_uint64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "add_associative", + expr: "5u + (15u + 20u) == (5u + 15u) + 20u", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _+_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 20u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n 5u~uint,\n _+_(\n 15u~uint,\n 20u~uint\n )~uint^add_uint64\n )~uint^add_uint64,\n _+_(\n _+_(\n 5u~uint,\n 15u~uint\n )~uint^add_uint64,\n 20u~uint\n )~uint^add_uint64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "mul_left_identity", + expr: "1u * 45u", + value: { uint64Value: "45" }, + }, + ast: "_*_(\n 1u^#*expr.Constant_Uint64Value#,\n 45u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 1u~uint,\n 45u~uint\n)~uint^multiply_uint64", + type: "uint", + }, + { + original: { + name: "mul_right_identity", + expr: "25u * 1u", + value: { uint64Value: "25" }, + }, + ast: "_*_(\n 25u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_*_(\n 25u~uint,\n 1u~uint\n)~uint^multiply_uint64", + type: "uint", + }, + { + original: { + name: "mul_commutative", + expr: "15u * 25u == 25u * 15u", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 25u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 15u~uint,\n 25u~uint\n )~uint^multiply_uint64,\n _*_(\n 25u~uint,\n 15u~uint\n )~uint^multiply_uint64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "mul_associative", + expr: "15u * (23u * 88u) == (15u * 23u) * 88u", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n _*_(\n 23u^#*expr.Constant_Uint64Value#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _*_(\n _*_(\n 15u^#*expr.Constant_Uint64Value#,\n 23u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 88u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 15u~uint,\n _*_(\n 23u~uint,\n 88u~uint\n )~uint^multiply_uint64\n )~uint^multiply_uint64,\n _*_(\n _*_(\n 15u~uint,\n 23u~uint\n )~uint^multiply_uint64,\n 88u~uint\n )~uint^multiply_uint64\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "add_mul_distribute", + expr: "5u * (15u + 25u) == 5u * 15u + 5u * 25u", + value: { boolValue: true }, + }, + ast: "_==_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n _+_(\n 15u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 15u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n _*_(\n 5u^#*expr.Constant_Uint64Value#,\n 25u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _*_(\n 5u~uint,\n _+_(\n 15u~uint,\n 25u~uint\n )~uint^add_uint64\n )~uint^multiply_uint64,\n _+_(\n _*_(\n 5u~uint,\n 15u~uint\n )~uint^multiply_uint64,\n _*_(\n 5u~uint,\n 25u~uint\n )~uint^multiply_uint64\n )~uint^add_uint64\n)~bool^equals", + type: "bool", + }, + ], + }, + ], + }, + { + name: "lists", + suites: [ + { + name: "concatenation", + tests: [ + { + original: { + name: "list_append", + expr: "[0, 1, 2] + [3, 4, 5] == [0, 1, 2, 3, 4, 5]", + value: { boolValue: true }, + }, + ast: "_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "list_not_commutative", + expr: "[0, 1, 2] + [3, 4, 5] == [3, 4, 5, 0, 1, 2]", + value: { boolValue: false }, + }, + ast: "_==_(\n _+_(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n _+_(\n [\n 0~int,\n 1~int,\n 2~int\n ]~list(int),\n [\n 3~int,\n 4~int,\n 5~int\n ]~list(int)\n )~list(int)^add_list,\n [\n 3~int,\n 4~int,\n 5~int,\n 0~int,\n 1~int,\n 2~int\n ]~list(int)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "list_repeat", + expr: "[2] + [2]", + value: { + listValue: { + values: [{ int64Value: "2" }, { int64Value: "2" }], + }, + }, + }, + ast: "_+_(\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n [\n 2~int\n ]~list(int),\n [\n 2~int\n ]~list(int)\n)~list(int)^add_list", + type: "list(int)", + }, + { + original: { + name: "empty_empty", + expr: "[] + []", + value: { listValue: {} }, + }, + ast: "_+_(\n []^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n []~list(dyn),\n []~list(dyn)\n)~list(dyn)^add_list", + type: "list(dyn)", + }, + { + original: { + name: "left_unit", + expr: "[] + [3, 4]", + value: { + listValue: { + values: [{ int64Value: "3" }, { int64Value: "4" }], + }, + }, + }, + ast: "_+_(\n []^#*expr.Expr_ListExpr#,\n [\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n []~list(int),\n [\n 3~int,\n 4~int\n ]~list(int)\n)~list(int)^add_list", + type: "list(int)", + }, + { + original: { + name: "right_unit", + expr: "[1, 2] + []", + value: { + listValue: { + values: [{ int64Value: "1" }, { int64Value: "2" }], + }, + }, + }, + ast: "_+_(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n [\n 1~int,\n 2~int\n ]~list(int),\n []~list(int)\n)~list(int)^add_list", + type: "list(int)", + }, + ], + }, + { + name: "index", + tests: [ + { + original: { + name: "zero_based", + expr: "[7, 8, 9][0]", + value: { int64Value: "7" }, + }, + ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n 0~int\n)~int^index_list", + type: "int", + }, + { + original: { + name: "zero_based_double", + expr: "[7, 8, 9][dyn(0.0)]", + value: { int64Value: "7" }, + }, + ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0~double\n )~dyn^to_dyn\n)~int^index_list", + type: "int", + }, + { + original: { + name: "zero_based_double_error", + expr: "[7, 8, 9][dyn(0.1)]", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0.1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0.1~double\n )~dyn^to_dyn\n)~int^index_list", + type: "int", + }, + { + original: { + name: "zero_based_uint", + expr: "[7, 8, 9][dyn(0u)]", + value: { int64Value: "7" }, + }, + ast: "_[_](\n [\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n 0u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 7~int,\n 8~int,\n 9~int\n ]~list(int),\n dyn(\n 0u~uint\n )~dyn^to_dyn\n)~int^index_list", + type: "int", + }, + { + original: { + name: "singleton", + expr: "['foo'][0]", + value: { stringValue: "foo" }, + }, + ast: '_[_](\n [\n "foo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n [\n "foo"~string\n ]~list(string),\n 0~int\n)~string^index_list', + type: "string", + }, + { + original: { + name: "middle", + expr: "[0, 1, 1, 2, 3, 5, 8, 13][4]", + value: { int64Value: "3" }, + }, + ast: "_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 0~int,\n 1~int,\n 1~int,\n 2~int,\n 3~int,\n 5~int,\n 8~int,\n 13~int\n ]~list(int),\n 4~int\n)~int^index_list", + type: "int", + }, + { + original: { + name: "last", + expr: "['George', 'John', 'Paul', 'Ringo'][3]", + value: { stringValue: "Ringo" }, + }, + ast: '_[_](\n [\n "George"^#*expr.Constant_StringValue#,\n "John"^#*expr.Constant_StringValue#,\n "Paul"^#*expr.Constant_StringValue#,\n "Ringo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n [\n "George"~string,\n "John"~string,\n "Paul"~string,\n "Ringo"~string\n ]~list(string),\n 3~int\n)~string^index_list', + type: "string", + }, + { + original: { + name: "index_out_of_bounds", + expr: "[1, 2, 3][3]", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: "_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n)~int^index_list", + type: "int", + }, + { + original: { + name: "index_out_of_bounds_or_false", + expr: "dyn([1, 2, 3][3]) || false", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: "_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "index_out_of_bounds_or_true", + expr: "dyn([1, 2, 3][3]) || true", + value: { boolValue: true }, + }, + ast: "_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "index_out_of_bounds_and_false", + expr: "dyn([1, 2, 3][3]) \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "index_out_of_bounds_and_true", + expr: "dyn([1, 2, 3][3]) \u0026\u0026 true", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n 3~int\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "bad_index_type", + expr: "[1, 2, 3][dyn('')]", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: '_[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n)~int^index_list', + type: "int", + }, + { + original: { + name: "bad_index_type_or_false", + expr: "dyn([1, 2, 3][dyn('')]) || false", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: '_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_or', + type: "bool", + }, + { + original: { + name: "bad_index_type_or_true", + expr: "dyn([1, 2, 3][dyn('')]) || true", + value: { boolValue: true }, + }, + ast: '_||_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_||_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_or', + type: "bool", + }, + { + original: { + name: "bad_index_type_and_false", + expr: "dyn([1, 2, 3][dyn('')]) \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n false~bool\n)~bool^logical_and', + type: "bool", + }, + { + original: { + name: "bad_index_type_and_true", + expr: "dyn([1, 2, 3][dyn('')]) \u0026\u0026 true", + evalError: { errors: [{ message: "invalid_argument" }] }, + }, + ast: '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u0026\u0026_(\n dyn(\n _[_](\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n dyn(\n ""~string\n )~dyn^to_dyn\n )~int^index_list\n )~dyn^to_dyn,\n true~bool\n)~bool^logical_and', + type: "bool", + }, + ], + }, + { + name: "in", + tests: [ + { + original: { + name: "empty", + expr: "7 in []", + value: { boolValue: false }, + }, + ast: "@in(\n 7^#*expr.Constant_Int64Value#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: "@in(\n 7~int,\n []~list(int)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "singleton", + expr: "4u in [4u]", + value: { boolValue: true }, + }, + ast: "@in(\n 4u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n 4u~uint,\n [\n 4u~uint\n ]~list(uint)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "first", + expr: "'alpha' in ['alpha', 'beta', 'gamma']", + value: { boolValue: true }, + }, + ast: '@in(\n "alpha"^#*expr.Constant_StringValue#,\n [\n "alpha"^#*expr.Constant_StringValue#,\n "beta"^#*expr.Constant_StringValue#,\n "gamma"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "alpha"~string,\n [\n "alpha"~string,\n "beta"~string,\n "gamma"~string\n ]~list(string)\n)~bool^in_list', + type: "bool", + }, + { + original: { + name: "middle", + expr: "3 in [5, 4, 3, 2, 1]", + value: { boolValue: true }, + }, + ast: "@in(\n 3^#*expr.Constant_Int64Value#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n 3~int,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "last", + expr: "20u in [4u, 6u, 8u, 12u, 20u]", + value: { boolValue: true }, + }, + ast: "@in(\n 20u^#*expr.Constant_Uint64Value#,\n [\n 4u^#*expr.Constant_Uint64Value#,\n 6u^#*expr.Constant_Uint64Value#,\n 8u^#*expr.Constant_Uint64Value#,\n 12u^#*expr.Constant_Uint64Value#,\n 20u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n 20u~uint,\n [\n 4u~uint,\n 6u~uint,\n 8u~uint,\n 12u~uint,\n 20u~uint\n ]~list(uint)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "double_in_ints", + expr: "dyn(3.0) in [5, 4, 3, 2, 1]", + value: { boolValue: true }, + }, + ast: "@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "uint_in_ints", + expr: "dyn(3u) in [5, 4, 3, 2, 1]", + value: { boolValue: true }, + }, + ast: "@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~int,\n 4~int,\n 3~int,\n 2~int,\n 1~int\n ]~list(int)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "int_in_doubles", + expr: "dyn(3) in [5.0, 4.0, 3.0, 2.0, 1.0]", + value: { boolValue: true }, + }, + ast: "@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "uint_in_doubles", + expr: "dyn(3u) in [5.0, 4.0, 3.0, 2.0, 1.0]", + value: { boolValue: true }, + }, + ast: "@in(\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5^#*expr.Constant_DoubleValue#,\n 4^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#,\n 2^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n [\n 5~double,\n 4~double,\n 3~double,\n 2~double,\n 1~double\n ]~list(double)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "int_in_uints", + expr: "dyn(3) in [5u, 4u, 3u, 2u, 1u]", + value: { boolValue: true }, + }, + ast: "@in(\n dyn(\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n dyn(\n 3~int\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "double_in_uints", + expr: "dyn(3.0) in [5u, 4u, 3u, 2u, 1u]", + value: { boolValue: true }, + }, + ast: "@in(\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n [\n 5u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "@in(\n dyn(\n 3~double\n )~dyn^to_dyn,\n [\n 5u~uint,\n 4u~uint,\n 3u~uint,\n 2u~uint,\n 1u~uint\n ]~list(uint)\n)~bool^in_list", + type: "bool", + }, + { + original: { + name: "missing", + expr: "'hawaiian' in ['meat', 'veggie', 'margarita', 'cheese']", + value: { boolValue: false }, + }, + ast: '@in(\n "hawaiian"^#*expr.Constant_StringValue#,\n [\n "meat"^#*expr.Constant_StringValue#,\n "veggie"^#*expr.Constant_StringValue#,\n "margarita"^#*expr.Constant_StringValue#,\n "cheese"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '@in(\n "hawaiian"~string,\n [\n "meat"~string,\n "veggie"~string,\n "margarita"~string,\n "cheese"~string\n ]~list(string)\n)~bool^in_list', + type: "bool", + }, + ], + }, + { + name: "size", + tests: [ + { + original: { + name: "list_empty", + expr: "size([])", + value: { int64Value: "0" }, + }, + ast: "size(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: "size(\n []~list(dyn)\n)~int^size_list", + type: "int", + }, + { + original: { + name: "list", + expr: "size([1, 2, 3])", + value: { int64Value: "3" }, + }, + ast: "size(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "size(\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n)~int^size_list", + type: "int", + }, + { + original: { + name: "map_empty", + expr: "size({})", + value: { int64Value: "0" }, + }, + ast: "size(\n {}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: "size(\n {}~map(dyn, dyn)\n)~int^size_map", + type: "int", + }, + { + original: { + name: "map", + expr: "size({1: 'one', 2: 'two', 3: 'three'})", + value: { int64Value: "3" }, + }, + ast: 'size(\n {\n 1^#*expr.Constant_Int64Value#:"one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:"three"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'size(\n {\n 1~int:"one"~string,\n 2~int:"two"~string,\n 3~int:"three"~string\n }~map(int, string)\n)~int^size_map', + type: "int", + }, + ], + }, + ], + }, + { + name: "logic", + suites: [ + { + name: "conditional", + tests: [ + { + original: { + name: "true_case", + expr: "true ? 1 : 2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n true~bool,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + { + original: { + name: "false_case", + expr: "false ? 'foo' : 'bar'", + value: { stringValue: "bar" }, + }, + ast: '_?_:_(\n false^#*expr.Constant_BoolValue#,\n "foo"^#*expr.Constant_StringValue#,\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_?_:_(\n false~bool,\n "foo"~string,\n "bar"~string\n)~string^conditional', + type: "string", + }, + { + original: { + name: "error_case", + expr: "2 / 0 \u003e 4 ? 'baz' : 'quux'", + evalError: { errors: [{ message: "division by zero" }] }, + }, + ast: '_?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "baz"^#*expr.Constant_StringValue#,\n "quux"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n "baz"~string,\n "quux"~string\n)~string^conditional', + type: "string", + }, + { + original: { + name: "mixed_type", + expr: "true ? 'cows' : 17", + disableCheck: true, + value: { stringValue: "cows" }, + }, + ast: '_?_:_(\n true^#*expr.Constant_BoolValue#,\n "cows"^#*expr.Constant_StringValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:6: found no matching overload for '_?_:_' applied to '(bool, string, int)'\n | true ? 'cows' : 17\n | .....^", + }, + { + original: { + name: "bad_type", + expr: "'cows' ? false : 17", + disableCheck: true, + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: '_?_:_(\n "cows"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:8: found no matching overload for '_?_:_' applied to '(string, bool, int)'\n | 'cows' ? false : 17\n | .......^", + }, + ], + }, + { + name: "AND", + tests: [ + { + original: { + name: "all_true", + expr: "true \u0026\u0026 true", + value: { boolValue: true }, + }, + ast: "_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n true~bool,\n true~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "all_false", + expr: "false \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n false~bool,\n false~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "false_left", + expr: "false \u0026\u0026 true", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n false~bool,\n true~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "false_right", + expr: "true \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n true~bool,\n false~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "short_circuit_type_left", + expr: "false \u0026\u0026 32", + disableCheck: true, + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:10: expected type 'bool' but found 'int'\n | false \u0026\u0026 32\n | .........^", + }, + { + original: { + name: "short_circuit_type_right", + expr: "'horses' \u0026\u0026 false", + disableCheck: true, + value: { boolValue: false }, + }, + ast: '_\u0026\u0026_(\n "horses"^#*expr.Constant_StringValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' \u0026\u0026 false\n | ^", + }, + { + original: { + name: "short_circuit_error_left", + expr: "false \u0026\u0026 (2 / 0 \u003e 3 ? false : true)", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n false^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n false~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "short_circuit_error_right", + expr: "(2 / 0 \u003e 3 ? false : true) \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n false~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "error_right", + expr: "true \u0026\u0026 1/0 != 0", + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: "_\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n true~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "error_left", + expr: "1/0 != 0 \u0026\u0026 true", + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: "_\u0026\u0026_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n true~bool\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "no_overload", + expr: "'less filling' \u0026\u0026 'tastes great'", + disableCheck: true, + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: '_\u0026\u0026_(\n "less filling"^#*expr.Constant_StringValue#,\n "tastes great"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' \u0026\u0026 'tastes great'\n | ..................^", + }, + ], + }, + { + name: "OR", + tests: [ + { + original: { + name: "all_true", + expr: "true || true", + value: { boolValue: true }, + }, + ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_||_(\n true~bool,\n true~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "all_false", + expr: "false || false", + value: { boolValue: false }, + }, + ast: "_||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n false~bool,\n false~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "false_left", + expr: "false || true", + value: { boolValue: true }, + }, + ast: "_||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n false~bool,\n true~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "false_right", + expr: "true || false", + value: { boolValue: true }, + }, + ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n true~bool,\n false~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "short_circuit_type_left", + expr: "true || 32", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n 32^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:9: expected type 'bool' but found 'int'\n | true || 32\n | ........^", + }, + { + original: { + name: "short_circuit_type_right", + expr: "'horses' || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: '_||_(\n "horses"^#*expr.Constant_StringValue#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'horses' || true\n | ^", + }, + { + original: { + name: "short_circuit_error_left", + expr: "true || (2 / 0 \u003e 3 ? false : true)", + value: { boolValue: true }, + }, + ast: "_||_(\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n true~bool,\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "short_circuit_error_right", + expr: "(2 / 0 \u003e 3 ? false : true) || true", + value: { boolValue: true }, + }, + ast: "_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n _?_:_(\n _\u003e_(\n _/_(\n 2~int,\n 0~int\n )~int^divide_int64,\n 3~int\n )~bool^greater_int64,\n false~bool,\n true~bool\n )~bool^conditional,\n true~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "error_right", + expr: "false || 1/0 != 0", + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: "_||_(\n false^#*expr.Constant_BoolValue#,\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n false~bool,\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "error_left", + expr: "1/0 != 0 || false", + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: "_||_(\n _!=_(\n _/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n _!=_(\n _/_(\n 1~int,\n 0~int\n )~int^divide_int64,\n 0~int\n )~bool^not_equals,\n false~bool\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "no_overload", + expr: "'less filling' || 'tastes great'", + disableCheck: true, + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: '_||_(\n "less filling"^#*expr.Constant_StringValue#,\n "tastes great"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:1: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ^\nERROR: \u003cinput\u003e:1:19: expected type 'bool' but found 'string'\n | 'less filling' || 'tastes great'\n | ..................^", + }, + ], + }, + { + name: "NOT", + tests: [ + { + original: { + name: "not_true", + expr: "!true", + value: { boolValue: false }, + }, + ast: "!_(\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "!_(\n true~bool\n)~bool^logical_not", + type: "bool", + }, + { + original: { + name: "not_false", + expr: "!false", + value: { boolValue: true }, + }, + ast: "!_(\n false^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "!_(\n false~bool\n)~bool^logical_not", + type: "bool", + }, + { + original: { + name: "no_overload", + expr: "!0", + disableCheck: true, + evalError: { errors: [{ message: "no matching overload" }] }, + }, + ast: "!_(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: found no matching overload for '!_' applied to '(int)'\n | !0\n | ^", + }, + ], + }, + ], + }, + { + name: "macros", + suites: [ + { + name: "exists", + tests: [ + { + original: { + name: "list_elem_all_true", + expr: "[1, 2, 3].exists(e, e \u003e 0)", + value: { boolValue: true }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_some_true", + expr: "[1, 2, 3].exists(e, e == 2)", + value: { boolValue: true }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_none_true", + expr: "[1, 2, 3].exists(e, e \u003e 3)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_type_shortcircuit", + description: "Exists filter is true for the last element.", + expr: "[1, 'foo', 3].exists(e, e != '1')", + value: { boolValue: true }, + }, + ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n e^#*expr.Expr_IdentExpr#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n e~dyn^e,\n "1"~string\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + { + original: { + name: "list_elem_type_exhaustive", + description: + "Exists filter is never true, but heterogenous equality ensure the result is false.", + expr: "[1, 'foo', 3].exists(e, e == '10')", + value: { boolValue: false }, + }, + ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n "10"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n "10"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + { + original: { + name: "list_elem_exists_error", + expr: "[1, 2, 3].exists(e, e / 0 == 17)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_empty", + expr: "[].exists(e, e == 2)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "map_key", + expr: "{'key1':1, 'key2':2}.exists(k, k == 'key2')", + value: { boolValue: true }, + }, + ast: '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"~string:1~int,\n "key2"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n "key2"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + { + original: { + name: "not_map_key", + expr: "!{'key1':1, 'key2':2}.exists(k, k == 'key3')", + value: { boolValue: true }, + }, + ast: '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key3"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"~string:1~int,\n "key2"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~string^k,\n "key3"~string\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not', + type: "bool", + }, + { + original: { + name: "map_key_type_shortcircuit", + description: "Exists filter is true for the second key", + expr: "{'key':1, 1:21}.exists(k, k != 2)", + value: { boolValue: true }, + }, + ast: '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key"~string:1~int,\n 1~int:21~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _!=_(\n k~dyn^k,\n 2~int\n )~bool^not_equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + { + original: { + name: "map_key_type_exhaustive", + description: + "Exists filter is never true, but heterogeneous equality ensures the result is false.", + expr: "!{'key':1, 1:42}.exists(k, k == 2)", + value: { boolValue: true }, + }, + ast: '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n false^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _||_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '!_(\n __comprehension__(\n // Variable\n k,\n // Target\n {\n "key"~string:1~int,\n 1~int:42~int\n }~map(dyn, int),\n // Accumulator\n @result,\n // Init\n false~bool,\n // LoopCondition\n @not_strictly_false(\n !_(\n @result~bool^@result\n )~bool^logical_not\n )~bool^not_strictly_false,\n // LoopStep\n _||_(\n @result~bool^@result,\n _==_(\n k~dyn^k,\n 2~int\n )~bool^equals\n )~bool^logical_or,\n // Result\n @result~bool^@result)~bool\n)~bool^logical_not', + type: "bool", + }, + ], + }, + { + name: "all", + tests: [ + { + original: { + name: "list_elem_all_true", + expr: "[1, 2, 3].all(e, e \u003e 0)", + value: { boolValue: true }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_some_true", + expr: "[1, 2, 3].all(e, e == 2)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 2~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_none_true", + expr: "[1, 2, 3].all(e, e == 17)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~int^e,\n 17~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_type_shortcircuit", + expr: "[1, 'foo', 3].all(e, e == 1)", + value: { boolValue: false }, + }, + ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n e^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n e~dyn^e,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + { + original: { + name: "list_elem_type_exhaustive", + expr: "[1, 'foo', 3].all(e, e % 2 == 1)", + evalError: { errors: [{ message: "no_such_overload" }] }, + }, + ast: '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n e^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n "foo"~string,\n 3~int\n ]~list(dyn),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _%_(\n e~dyn^e,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + { + original: { + name: "list_elem_error_shortcircuit", + expr: "[1, 2, 3].all(e, 6 / (2 - e) == 6)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n e^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n _/_(\n 6~int,\n _-_(\n 2~int,\n e~int^e\n )~int^subtract_int64\n )~int^divide_int64,\n 6~int\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_elem_error_exhaustive", + expr: "[1, 2, 3].all(e, e / 0 != 17)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _!=_(\n _/_(\n e~int^e,\n 0~int\n )~int^divide_int64,\n 17~int\n )~bool^not_equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "list_empty", + expr: "[].all(e, e \u003e 0)", + value: { boolValue: true }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _\u003e_(\n e~int^e,\n 0~int\n )~bool^greater_int64\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool", + type: "bool", + }, + { + original: { + name: "map_key", + expr: "{'key1':1, 'key2':2}.all(k, k == 'key2')", + value: { boolValue: false }, + }, + ast: '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n k,\n // Target\n {\n "key1"~string:1~int,\n "key2"~string:2~int\n }~map(string, int),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n _==_(\n k~string^k,\n "key2"~string\n )~bool^equals\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + ], + }, + { + name: "exists_one", + tests: [ + { + original: { + name: "list_empty", + expr: "[].exists_one(a, a == 7)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n a,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n a,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "list_one_true", + expr: "[7].exists_one(a, a == 7)", + value: { boolValue: true }, + }, + ast: "__comprehension__(\n // Variable\n a,\n // Target\n [\n 7^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n a,\n // Target\n [\n 7~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "list_one_false", + expr: "[8].exists_one(a, a == 7)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n a,\n // Target\n [\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n a^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n a,\n // Target\n [\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n a~int^a,\n 7~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "list_none", + expr: "[1, 2, 3].exists_one(x, x \u003e 20)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n x,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n x^#*expr.Expr_IdentExpr#,\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n x,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n x~int^x,\n 20~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "list_one", + expr: "[6, 7, 8].exists_one(foo, foo % 5 == 2)", + value: { boolValue: true }, + }, + ast: "__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n foo,\n // Target\n [\n 6~int,\n 7~int,\n 8~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "list_many", + expr: "[0, 1, 2, 3, 4].exists_one(n, n % 2 == 1)", + value: { boolValue: false }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "list_all", + expr: "['foal', 'foo', 'four'].exists_one(n, n.startsWith('fo'))", + value: { boolValue: false }, + }, + ast: '__comprehension__(\n // Variable\n n,\n // Target\n [\n "foal"^#*expr.Constant_StringValue#,\n "foo"^#*expr.Constant_StringValue#,\n "four"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n n^#*expr.Expr_IdentExpr#.startsWith(\n "fo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n n,\n // Target\n [\n "foal"~string,\n "foo"~string,\n "four"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n n~string^n.startsWith(\n "fo"~string\n )~bool^starts_with_string,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool', + type: "bool", + }, + { + original: { + name: "list_no_shortcircuit", + description: + "Errors invalidate everything, even if already false.", + expr: "[3, 2, 1, 0].exists_one(n, 12 / n \u003e 1)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 1~int\n )~bool^greater_int64,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool", + type: "bool", + }, + { + original: { + name: "map_one", + expr: "{6: 'six', 7: 'seven', 8: 'eight'}.exists_one(foo, foo % 5 == 2)", + value: { boolValue: true }, + }, + ast: '__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6^#*expr.Constant_Int64Value#:"six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:"seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:"eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n 0^#*expr.Constant_Int64Value#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n _==_(\n @result^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n foo,\n // Target\n {\n 6~int:"six"~string,\n 7~int:"seven"~string,\n 8~int:"eight"~string\n }~map(int, string),\n // Accumulator\n @result,\n // Init\n 0~int,\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n foo~int^foo,\n 5~int\n )~int^modulo_int64,\n 2~int\n )~bool^equals,\n _+_(\n @result~int^@result,\n 1~int\n )~int^add_int64,\n @result~int^@result\n )~int^conditional,\n // Result\n _==_(\n @result~int^@result,\n 1~int\n )~bool^equals)~bool', + type: "bool", + }, + ], + }, + { + name: "map", + tests: [ + { + original: { + name: "list_empty", + expr: "[].map(n, n / 2)", + value: { listValue: {} }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_one", + expr: "[3].map(n, n * n)", + value: { listValue: { values: [{ int64Value: "9" }] } }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _*_(\n n^#*expr.Expr_IdentExpr#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _*_(\n n~int^n,\n n~int^n\n )~int^multiply_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_many", + expr: "[2, 4, 6].map(n, n / 2)", + value: { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + { int64Value: "3" }, + ], + }, + }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 4~int,\n 6~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n n~int^n,\n 2~int\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_error", + expr: "[2, 1, 0].map(n, 4 / n)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n _/_(\n 4^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n _/_(\n 4~int,\n n~int^n\n )~int^divide_int64\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "map_extract_keys", + expr: "{'John': 'smart'}.map(key, key) == ['John']", + value: { boolValue: true }, + }, + ast: '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"^#*expr.Constant_StringValue#:"smart"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n "John"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"~string:"smart"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n // Result\n @result~list(string)^@result)~list(string),\n [\n "John"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "filter", + tests: [ + { + original: { + name: "list_empty", + expr: "[].filter(n, n % 2 == 0)", + value: { listValue: {} }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n []~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n n~int^n,\n 2~int\n )~int^modulo_int64,\n 0~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_one_true", + expr: "[2].filter(n, n == 2)", + value: { listValue: { values: [{ int64Value: "2" }] } }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n n^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 2~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n n~int^n,\n 2~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_one_false", + expr: "[1].filter(n, n \u003e 3)", + value: { listValue: {} }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_none", + expr: "[1, 2, 3].filter(e, e \u003e 3)", + value: { listValue: {} }, + }, + ast: "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n e^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n e^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n e,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n e~int^e,\n 3~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n e~int^e\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_some", + expr: "[0, 1, 2, 3, 4].filter(x, x % 2 == 1)", + value: { + listValue: { + values: [{ int64Value: "1" }, { int64Value: "3" }], + }, + }, + }, + ast: "__comprehension__(\n // Variable\n x,\n // Target\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n x,\n // Target\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n _%_(\n x~int^x,\n 2~int\n )~int^modulo_int64,\n 1~int\n )~bool^equals,\n _+_(\n @result~list(int)^@result,\n [\n x~int^x\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_all", + expr: "[1, 2, 3].filter(n, n \u003e 0)", + value: { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "2" }, + { int64Value: "3" }, + ], + }, + }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n n^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 1~int,\n 2~int,\n 3~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n n~int^n,\n 0~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "list_no_shortcircuit", + expr: "[3, 2, 1, 0].filter(n, 12 / n \u003e 4)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12^#*expr.Constant_Int64Value#,\n n^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n n^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n n,\n // Target\n [\n 3~int,\n 2~int,\n 1~int,\n 0~int\n ]~list(int),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _\u003e_(\n _/_(\n 12~int,\n n~int^n\n )~int^divide_int64,\n 4~int\n )~bool^greater_int64,\n _+_(\n @result~list(int)^@result,\n [\n n~int^n\n ]~list(int)\n )~list(int)^add_list,\n @result~list(int)^@result\n )~list(int)^conditional,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "map_filter_keys", + expr: "{'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}.filter(key, key == 'Ringo') == ['Ringo']", + value: { boolValue: true }, + }, + ast: '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"^#*expr.Constant_StringValue#:"smart"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Paul"^#*expr.Constant_StringValue#:"cute"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "George"^#*expr.Constant_StringValue#:"quiet"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "Ringo"^#*expr.Constant_StringValue#:"funny"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n _==_(\n key^#*expr.Expr_IdentExpr#,\n "Ringo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n key^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n [\n "Ringo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n __comprehension__(\n // Variable\n key,\n // Target\n {\n "John"~string:"smart"~string,\n "Paul"~string:"cute"~string,\n "George"~string:"quiet"~string,\n "Ringo"~string:"funny"~string\n }~map(string, string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n _==_(\n key~string^key,\n "Ringo"~string\n )~bool^equals,\n _+_(\n @result~list(string)^@result,\n [\n key~string^key\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string),\n [\n "Ringo"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "nested", + tests: [ + { + original: { + name: "filter_all", + expr: "['signer'].filter(signer, ['artifact'].all(artifact, true))", + value: { listValue: { values: [{ stringValue: "signer" }] } }, + }, + ast: '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n signer^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n []~list(string),\n // LoopCondition\n true~bool,\n // LoopStep\n _?_:_(\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool,\n _+_(\n @result~list(string)^@result,\n [\n signer~string^signer\n ]~list(string)\n )~list(string)^add_list,\n @result~list(string)^@result\n )~list(string)^conditional,\n // Result\n @result~list(string)^@result)~list(string)', + type: "list(string)", + }, + { + original: { + name: "all_all", + expr: "['signer'].all(signer, ['artifact'].all(artifact, true))", + value: { boolValue: true }, + }, + ast: '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n true^#*expr.Constant_BoolValue#,\n // LoopCondition\n @not_strictly_false(\n @result^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n // LoopStep\n _\u0026\u0026_(\n @result^#*expr.Expr_IdentExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#', + checkedAst: + '__comprehension__(\n // Variable\n signer,\n // Target\n [\n "signer"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n __comprehension__(\n // Variable\n artifact,\n // Target\n [\n "artifact"~string\n ]~list(string),\n // Accumulator\n @result,\n // Init\n true~bool,\n // LoopCondition\n @not_strictly_false(\n @result~bool^@result\n )~bool^not_strictly_false,\n // LoopStep\n _\u0026\u0026_(\n @result~bool^@result,\n true~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool\n )~bool^logical_and,\n // Result\n @result~bool^@result)~bool', + type: "bool", + }, + ], + }, + ], + }, + { + name: "macros2", + suites: [ + { + name: "exists", + tests: [ + { + original: { + name: "list_elem_all_true", + expr: "[1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)", + value: { boolValue: true }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................................^", + }, + { + original: { + name: "list_elem_some_true", + expr: "[1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)", + value: { boolValue: true }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .......................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i == 1 \u0026\u0026 v == 2)\n | .................................^", + }, + { + original: { + name: "list_elem_none_true", + expr: "[1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)", + value: { boolValue: false }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, i \u003e 2 \u0026\u0026 v \u003e 3)\n | ................................^", + }, + { + original: { + name: "list_elem_type_shortcircuit", + expr: "[1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')", + value: { boolValue: true }, + }, + ast: '[\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 1 \u0026\u0026 v != '1')\n | .....................................^", + }, + { + original: { + name: "list_elem_type_exhaustive", + expr: "[1, 'foo', 3].exists(i, v, i == 3 || v == '10')", + value: { boolValue: false }, + }, + ast: '[\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "10"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:21: undeclared reference to 'exists' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ....................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | ...........................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].exists(i, v, i == 3 || v == '10')\n | .....................................^", + }, + { + original: { + name: "list_elem_exists_error", + expr: "[1, 2, 3].exists(i, v, v / i == 17)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'exists' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'i' (in container '')\n | [1, 2, 3].exists(i, v, v / i == 17)\n | ...........................^", + }, + { + original: { + name: "list_empty", + expr: "[].exists(i, v, i == 0 || v == 2)", + value: { boolValue: false }, + }, + ast: "[]^#*expr.Expr_ListExpr#.exists(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:10: undeclared reference to 'exists' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .........^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'i' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [].exists(i, v, i == 0 || v == 2)\n | ..........................^", + }, + { + original: { + name: "map_key", + expr: "{'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)", + value: { boolValue: true }, + }, + ast: '{\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:28: undeclared reference to 'exists' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..................................^\nERROR: \u003cinput\u003e:1:50: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.exists(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .................................................^", + }, + { + original: { + name: "not_map_key", + expr: "!{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)", + value: { boolValue: true }, + }, + ast: '!_(\n {\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key3"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:29: undeclared reference to 'exists' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ............................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ................................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'k' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ...................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | !{'key1':1, 'key2':2}.exists(k, v, k == 'key3' || v == 3)\n | ..................................................^", + }, + { + original: { + name: "map_key_type_shortcircuit", + expr: "{'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)", + value: { boolValue: true }, + }, + ast: '{\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:21^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:23: undeclared reference to 'exists' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'k' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .............................^\nERROR: \u003cinput\u003e:1:40: undeclared reference to 'v' (in container '')\n | {'key':1, 1:21}.exists(k, v, k != 2 \u0026\u0026 v != 22)\n | .......................................^", + }, + { + original: { + name: "map_key_type_exhaustive", + expr: "!{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)", + value: { boolValue: true }, + }, + ast: '!_(\n {\n "key"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.exists(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 43^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'exists' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'k' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | !{'key':1, 1:42}.exists(k, v, k == 2 \u0026\u0026 v == 43)\n | ........................................^", + }, + ], + }, + { + name: "all", + tests: [ + { + original: { + name: "list_elem_all_true", + expr: "[1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)", + value: { boolValue: true }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i \u003e -1 \u0026\u0026 v \u003e 0)\n | ..............................^", + }, + { + original: { + name: "list_elem_some_true", + expr: "[1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)", + value: { boolValue: false }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 1 \u0026\u0026 v == 2)\n | ..............................^", + }, + { + original: { + name: "list_elem_none_true", + expr: "[1, 2, 3].all(i, v, i == 3 || v == 4)", + value: { boolValue: false }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, i == 3 || v == 4)\n | ..............................^", + }, + { + original: { + name: "list_elem_type_shortcircuit", + expr: "[1, 'foo', 3].all(i, v, i == 0 || v == 1)", + value: { boolValue: false }, + }, + ast: '[\n 1^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [1, 'foo', 3].all(i, v, i == 0 || v == 1)\n | ..................................^", + }, + { + original: { + name: "list_elem_type_exhaustive", + expr: "[0, 'foo', 3].all(i, v, v % 2 == i)", + value: { boolValue: false }, + }, + ast: '[\n 0^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 3].all(i, v, v % 2 == i)\n | .................................^", + }, + { + original: { + name: "list_elem_type_error_exhaustive", + expr: "[0, 'foo', 5].all(i, v, v % 3 == i)", + evalError: { errors: [{ message: "no_such_overload" }] }, + }, + ast: '[\n 0^#*expr.Constant_Int64Value#,\n "foo"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'all' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | ........................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [0, 'foo', 5].all(i, v, v % 3 == i)\n | .................................^", + }, + { + original: { + name: "list_elem_error_shortcircuit", + expr: "[1, 2, 3].all(i, v, 6 / (2 - v) == i)", + value: { boolValue: false }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _/_(\n 6^#*expr.Constant_Int64Value#,\n _-_(\n 2^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | .............................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, 6 / (2 - v) == i)\n | ...................................^", + }, + { + original: { + name: "list_elem_error_exhaustive", + expr: "[1, 2, 3].all(i, v, v / i != 17)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _!=_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'all' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [1, 2, 3].all(i, v, v / i != 17)\n | ........................^", + }, + { + original: { + name: "list_empty", + expr: "[].all(i, v, i \u003e -1 || v \u003e 0)", + value: { boolValue: true }, + }, + ast: "[]^#*expr.Expr_ListExpr#.all(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:7: undeclared reference to 'all' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ......^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | ..........^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .............^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [].all(i, v, i \u003e -1 || v \u003e 0)\n | .......................^", + }, + { + original: { + name: "map_key", + expr: "{'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)", + value: { boolValue: false }, + }, + ast: '{\n "key1"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.all(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "key2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:25: undeclared reference to 'all' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ........................^\nERROR: \u003cinput\u003e:1:26: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | .........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'k' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ...............................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | {'key1':1, 'key2':2}.all(k, v, k == 'key2' \u0026\u0026 v == 2)\n | ..............................................^", + }, + ], + }, + { + name: "existsOne", + tests: [ + { + original: { + name: "list_empty", + expr: "[].existsOne(i, v, i == 3 || v == 7)", + value: { boolValue: false }, + }, + ast: "[]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:13: undeclared reference to 'existsOne' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ............^\nERROR: \u003cinput\u003e:1:14: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'i' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | ...................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [].existsOne(i, v, i == 3 || v == 7)\n | .............................^", + }, + { + original: { + name: "list_one_true", + expr: "[7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)", + value: { boolValue: true }, + }, + ast: "[\n 7^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [7].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^", + }, + { + original: { + name: "list_one_false", + expr: "[8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)", + value: { boolValue: false }, + }, + ast: "[\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:14: undeclared reference to 'existsOne' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .............^\nERROR: \u003cinput\u003e:1:15: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ....................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [8].existsOne(i, v, i == 0 \u0026\u0026 v == 7)\n | ..............................^", + }, + { + original: { + name: "list_none", + expr: "[1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)", + value: { boolValue: false }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _||_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _\u003e_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'v' (in container '')\n | [1, 2, 3].existsOne(i, v, i \u003e 2 || v \u003e 3)\n | ...................................^", + }, + { + original: { + name: "list_one", + expr: "[5, 7, 8].existsOne(i, v, v % 5 == i)", + value: { boolValue: true }, + }, + ast: "[\n 5^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:20: undeclared reference to 'existsOne' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:36: undeclared reference to 'i' (in container '')\n | [5, 7, 8].existsOne(i, v, v % 5 == i)\n | ...................................^", + }, + { + original: { + name: "list_many", + expr: "[0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)", + value: { boolValue: false }, + }, + ast: "[\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _==_(\n _%_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:26: undeclared reference to 'existsOne' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'v' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | ................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'i' (in container '')\n | [0, 1, 2, 3, 4].existsOne(i, v, v % 2 == i)\n | .........................................^", + }, + { + original: { + name: "list_all", + expr: "['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))", + value: { boolValue: false }, + }, + ast: '[\n "foal"^#*expr.Constant_StringValue#,\n "foo"^#*expr.Constant_StringValue#,\n "four"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#.startsWith(\n "fo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:34: undeclared reference to 'existsOne' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .................................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................^\nERROR: \u003cinput\u003e:1:38: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | .....................................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'i' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ........................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'v' (in container '')\n | ['foal', 'foo', 'four'].existsOne(i, v, i \u003e -1 \u0026\u0026 v.startsWith('fo'))\n | ..................................................^", + }, + { + original: { + name: "list_no_shortcircuit", + expr: "[3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "[\n 3^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.existsOne(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:23: undeclared reference to 'existsOne' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ......................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | ..........................^\nERROR: \u003cinput\u003e:1:30: undeclared reference to 'v' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .............................^\nERROR: \u003cinput\u003e:1:34: undeclared reference to 'i' (in container '')\n | [3, 2, 1, 0].existsOne(i, v, v / i \u003e 1)\n | .................................^", + }, + { + original: { + name: "map_one", + expr: "{6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')", + value: { boolValue: true }, + }, + ast: '{\n 6^#*expr.Constant_Int64Value#:"six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:"seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:"eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.existsOne(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n _%_(\n k^#*expr.Expr_IdentExpr#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "seven"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:45: undeclared reference to 'existsOne' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ............................................^\nERROR: \u003cinput\u003e:1:46: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .............................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ................................................^\nERROR: \u003cinput\u003e:1:52: undeclared reference to 'k' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | ...................................................^\nERROR: \u003cinput\u003e:1:66: undeclared reference to 'v' (in container '')\n | {6: 'six', 7: 'seven', 8: 'eight'}.existsOne(k, v, k % 5 == 2 \u0026\u0026 v == 'seven')\n | .................................................................^", + }, + ], + }, + { + name: "transformList", + tests: [ + { + original: { + name: "empty", + expr: "[].transformList(i, v, i / v)", + value: { listValue: {} }, + }, + ast: "[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i / v)\n | ...........................^", + }, + { + original: { + name: "empty_filter", + expr: "[].transformList(i, v, i \u003e v, i / v)", + value: { listValue: {} }, + }, + ast: "[]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n _/_(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:17: undeclared reference to 'transformList' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ................^\nERROR: \u003cinput\u003e:1:18: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .................^\nERROR: \u003cinput\u003e:1:21: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ....................^\nERROR: \u003cinput\u003e:1:24: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | .......................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [].transformList(i, v, i \u003e v, i / v)\n | ..................................^", + }, + { + original: { + name: "one", + expr: "[3].transformList(i, v, v * v + i)", + value: { listValue: { values: [{ int64Value: "9" }] } }, + }, + ast: "[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ............................^\nERROR: \u003cinput\u003e:1:33: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, v * v + i)\n | ................................^", + }, + { + original: { + name: "one_filter", + expr: "[3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)", + value: { listValue: { values: [{ int64Value: "9" }] } }, + }, + ast: "[\n 3^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n i^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _*_(\n v^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:18: undeclared reference to 'transformList' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .................^\nERROR: \u003cinput\u003e:1:19: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................^\nERROR: \u003cinput\u003e:1:22: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | .....................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ........................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................^\nERROR: \u003cinput\u003e:1:43: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..........................................^\nERROR: \u003cinput\u003e:1:47: undeclared reference to 'v' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'i' (in container '')\n | [3].transformList(i, v, i == 0 \u0026\u0026 v == 3, v * v + i)\n | ..................................................^", + }, + { + original: { + name: "many", + expr: "[2, 4, 6].transformList(i, v, v / 2 + i)", + value: { + listValue: { + values: [ + { int64Value: "1" }, + { int64Value: "3" }, + { int64Value: "5" }, + ], + }, + }, + }, + ast: "[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, v / 2 + i)\n | ......................................^", + }, + { + original: { + name: "many_filter", + expr: "[2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)", + value: { + listValue: { + values: [{ int64Value: "1" }, { int64Value: "5" }], + }, + }, + }, + ast: "[\n 2^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n i^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ..............................^\nERROR: \u003cinput\u003e:1:41: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ................................................^\nERROR: \u003cinput\u003e:1:57: undeclared reference to 'i' (in container '')\n | [2, 4, 6].transformList(i, v, i != 1 \u0026\u0026 v != 4, v / 2 + i)\n | ........................................................^", + }, + { + original: { + name: "error", + expr: "[2, 1, 0].transformList(i, v, v / i)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i)\n | ..................................^", + }, + { + original: { + name: "error_filter", + expr: "[2, 1, 0].transformList(i, v, v / i \u003e 0, v)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: "[\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#.transformList(\n i^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u003e_(\n _/_(\n v^#*expr.Expr_IdentExpr#,\n i^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: undeclared reference to 'transformList' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .......................^\nERROR: \u003cinput\u003e:1:25: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ........................^\nERROR: \u003cinput\u003e:1:28: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ...........................^\nERROR: \u003cinput\u003e:1:31: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'i' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | ..................................^\nERROR: \u003cinput\u003e:1:42: undeclared reference to 'v' (in container '')\n | [2, 1, 0].transformList(i, v, v / i \u003e 0, v)\n | .........................................^", + }, + ], + }, + { + name: "transformMap", + tests: [ + { + original: { + name: "empty", + expr: "{}.transformMap(k, v, k + v)", + value: { mapValue: {} }, + }, + ast: "{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:27: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k + v)\n | ..........................^", + }, + { + original: { + name: "empty_filter", + expr: "{}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)", + value: { mapValue: {} }, + }, + ast: '{}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "foo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "bar"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:16: undeclared reference to 'transformMap' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............^\nERROR: \u003cinput\u003e:1:17: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................^\nERROR: \u003cinput\u003e:1:20: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...................^\nERROR: \u003cinput\u003e:1:23: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ......................^\nERROR: \u003cinput\u003e:1:37: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'k' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:53: undeclared reference to 'v' (in container '')\n | {}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ....................................................^", + }, + { + original: { + name: "one", + expr: "{'foo': 'bar'}.transformMap(k, v, k + v)", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "foo" }, + value: { stringValue: "foobar" }, + }, + ], + }, + }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:39: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k + v)\n | ......................................^", + }, + { + original: { + name: "one_filter", + expr: "{'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "foo" }, + value: { stringValue: "foobar" }, + }, + ], + }, + }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "foo"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n v^#*expr.Expr_IdentExpr#,\n "bar"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:28: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...........................^\nERROR: \u003cinput\u003e:1:29: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................^\nERROR: \u003cinput\u003e:1:32: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ...............................^\nERROR: \u003cinput\u003e:1:35: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ..................................^\nERROR: \u003cinput\u003e:1:49: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:65: undeclared reference to 'v' (in container '')\n | {'foo': 'bar'}.transformMap(k, v, k == 'foo' \u0026\u0026 v == 'bar', k + v)\n | ................................................................^", + }, + { + original: { + name: "many", + expr: "{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "foo" }, + value: { stringValue: "foobar" }, + }, + { + key: { stringValue: "baz" }, + value: { stringValue: "bazbux" }, + }, + { + key: { stringValue: "hello" }, + value: { stringValue: "helloworld" }, + }, + ], + }, + }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:"bux"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "hello"^#*expr.Constant_StringValue#:"world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:71: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k + v)\n | ......................................................................^", + }, + { + original: { + name: "many_filter", + expr: "{'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "foo" }, + value: { stringValue: "foobar" }, + }, + { + key: { stringValue: "hello" }, + value: { stringValue: "helloworld" }, + }, + ], + }, + }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:"bar"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:"bux"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "hello"^#*expr.Constant_StringValue#:"world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _!=_(\n k^#*expr.Expr_IdentExpr#,\n "baz"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _!=_(\n v^#*expr.Expr_IdentExpr#,\n "bux"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _+_(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:60: undeclared reference to 'transformMap' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...........................................................^\nERROR: \u003cinput\u003e:1:61: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................^\nERROR: \u003cinput\u003e:1:64: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ...............................................................^\nERROR: \u003cinput\u003e:1:67: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ..................................................................^\nERROR: \u003cinput\u003e:1:81: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................^\nERROR: \u003cinput\u003e:1:93: undeclared reference to 'k' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ............................................................................................^\nERROR: \u003cinput\u003e:1:97: undeclared reference to 'v' (in container '')\n | {'foo': 'bar', 'baz': 'bux', 'hello': 'world'}.transformMap(k, v, k != 'baz' \u0026\u0026 v != 'bux', k + v)\n | ................................................................................................^", + }, + { + original: { + name: "error", + expr: "{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "bar"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:55: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, 4 / v)\n | ......................................................^", + }, + { + original: { + name: "error_filter", + expr: "{'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)", + evalError: { errors: [{ message: "divide by zero" }] }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "bar"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "baz"^#*expr.Constant_StringValue#:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.transformMap(\n k^#*expr.Expr_IdentExpr#,\n v^#*expr.Expr_IdentExpr#,\n _\u0026\u0026_(\n _==_(\n k^#*expr.Expr_IdentExpr#,\n "baz"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n _/_(\n 4^#*expr.Constant_Int64Value#,\n v^#*expr.Expr_IdentExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n v^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:44: undeclared reference to 'transformMap' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...........................................^\nERROR: \u003cinput\u003e:1:45: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................^\nERROR: \u003cinput\u003e:1:48: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ...............................................^\nERROR: \u003cinput\u003e:1:51: undeclared reference to 'k' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ..................................................^\nERROR: \u003cinput\u003e:1:69: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ....................................................................^\nERROR: \u003cinput\u003e:1:77: undeclared reference to 'v' (in container '')\n | {'foo': 2, 'bar': 1, 'baz': 0}.transformMap(k, v, k == 'baz' \u0026\u0026 4 / v == 0, v)\n | ............................................................................^", + }, + ], + }, + ], + }, + { + name: "math_ext", + suites: [ + { + name: "greatest_int_result", + tests: [ + { + original: { + name: "unary_negative", + expr: "math.greatest(-5)", + value: { int64Value: "-5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@max(\n -5~int\n)~int^math_@max_int", + type: "int", + }, + { + original: { + name: "unary_positive", + expr: "math.greatest(5)", + value: { int64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@max(\n 5~int\n)~int^math_@max_int", + type: "int", + }, + { + original: { + name: "binary_same_args", + expr: "math.greatest(1, 1)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1~int,\n 1~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "binary_with_decimal", + expr: "math.greatest(1, 1.0) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n 1~int,\n 1~double\n )~dyn^math_@max_int_double,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_with_uint", + expr: "math.greatest(1, 1u) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n 1~int,\n 1u~uint\n )~dyn^math_@max_int_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_first_arg_greater", + expr: "math.greatest(3, -3)", + value: { int64Value: "3" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 3^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 3~int,\n -3~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "binary_second_arg_greater", + expr: "math.greatest(-7, 5)", + value: { int64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -7^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n -7~int,\n 5~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "binary_first_arg_int_max", + expr: "math.greatest(9223372036854775807, 1)", + value: { int64Value: "9223372036854775807" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 9223372036854775807~int,\n 1~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "binary_second_arg_int_max", + expr: "math.greatest(1, 9223372036854775807)", + value: { int64Value: "9223372036854775807" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1~int,\n 9223372036854775807~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "binary_first_arg_int_min", + expr: "math.greatest(-9223372036854775808, 1)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n -9223372036854775808~int,\n 1~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "binary_second_arg_int_min", + expr: "math.greatest(1, -9223372036854775808)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1~int,\n -9223372036854775808~int\n)~int^math_@max_int_int", + type: "int", + }, + { + original: { + name: "ternary_same_args", + expr: "math.greatest(1, 1, 1) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@max_list_int,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_decimal", + expr: "math.greatest(1, 1.0, 1.0) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_uint", + expr: "math.greatest(1, 1u, 1u) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_first_arg_greatest", + expr: "math.greatest(10, 1, 3) == 10", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 10~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_third_arg_greatest", + expr: "math.greatest(1, 3, 10) == 10", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~int,\n 3~int,\n 10~int\n ]~list(int)\n )~int^math_@max_list_int,\n 10~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_negatives", + expr: "math.greatest(-1, -2, -3) == -1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_int_max", + expr: "math.greatest(9223372036854775807, 1, 5) == 9223372036854775807", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@max_list_int,\n 9223372036854775807~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_int_min", + expr: "math.greatest(-9223372036854775807, -1, -5) == -1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -9223372036854775807^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n -9223372036854775807~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@max_list_int,\n -1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed", + expr: "math.greatest(5.4, 10, 3u, -5.0, 9223372036854775807) == 9223372036854775807", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 9223372036854775807~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_array", + expr: "math.greatest([5.4, 10, 3u, -5.0, 3.5]) == 10", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_dyn_array", + expr: "math.greatest([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10~int\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "greatest_double_result", + tests: [ + { + original: { + name: "unary_negative", + expr: "math.greatest(-5.0)", + value: { doubleValue: -5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@max(\n -5~double\n)~double^math_@max_double", + type: "double", + }, + { + original: { + name: "unary_positive", + expr: "math.greatest(5.0)", + value: { doubleValue: 5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@max(\n 5~double\n)~double^math_@max_double", + type: "double", + }, + { + original: { + name: "binary_same_args", + expr: "math.greatest(1.0, 1.0)", + value: { doubleValue: 1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1~double,\n 1~double\n)~double^math_@max_double_double", + type: "double", + }, + { + original: { + name: "binary_with_int", + expr: "math.greatest(1.0, 1) == 1.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n 1~double,\n 1~int\n )~dyn^math_@max_double_int,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_with_uint", + expr: "math.greatest(1.0, 1u) == 1.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n 1~double,\n 1u~uint\n )~dyn^math_@max_double_uint,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_first_arg_greater", + expr: "math.greatest(5.0, -7.0)", + value: { doubleValue: 5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5^#*expr.Constant_DoubleValue#,\n -7^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 5~double,\n -7~double\n)~double^math_@max_double_double", + type: "double", + }, + { + original: { + name: "binary_second_arg_greater", + expr: "math.greatest(-3.0, 3.0)", + value: { doubleValue: 3 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_DoubleValue#,\n 3^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n -3~double,\n 3~double\n)~double^math_@max_double_double", + type: "double", + }, + { + original: { + name: "binary_first_arg_double_max", + expr: "math.greatest(1.797693e308, 1)", + value: { doubleValue: 1.797693e308 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1.797693e+308~double,\n 1~int\n)~dyn^math_@max_double_int", + type: "dyn", + }, + { + original: { + name: "binary_second_arg_double_max", + expr: "math.greatest(1, 1.797693e308)", + value: { doubleValue: 1.797693e308 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_Int64Value#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1~int,\n 1.797693e+308~double\n)~dyn^math_@max_int_double", + type: "dyn", + }, + { + original: { + name: "binary_first_arg_double_min", + expr: "math.greatest(-1.797693e308, 1.5)", + value: { doubleValue: 1.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@max_double_double", + type: "double", + }, + { + original: { + name: "binary_second_arg_double_min", + expr: "math.greatest(1.5, -1.797693e308)", + value: { doubleValue: 1.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@max_double_double", + type: "double", + }, + { + original: { + name: "ternary_same_args", + expr: "math.greatest(1.0, 1.0, 1.0) == 1.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~double,\n 1~double,\n 1~double\n ]~list(double)\n )~double^math_@max_list_double,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_int", + expr: "math.greatest(1.0, 1, 1) == 1.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_uint", + expr: "math.greatest(1.0, 1u, 1u) == 1.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_first_arg_greatest", + expr: "math.greatest(10.5, 1.5, 3.5) == 10.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 10.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_third_arg_greatest", + expr: "math.greatest(1.5, 3.5, 10.5) == 10.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1.5~double,\n 3.5~double,\n 10.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n 10.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_negatives", + expr: "math.greatest(-1.5, -2.5, -3.5) == -1.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@max_list_double,\n -1.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_double_max", + expr: "math.greatest(1.797693e308, 1, 5) == 1.797693e308", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_double_min", + expr: "math.greatest(-1.797693e308, -1, -5) == -1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n -1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed", + expr: "math.greatest(5.4, 10, 3u, -5.0, 1.797693e308) == 1.797693e308", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1.797693e+308~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_array", + expr: "math.greatest([5.4, 10.5, 3u, -5.0, 3.5]) == 10.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_dyn_array", + expr: "math.greatest([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10.5~double\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "greatest_uint_result", + tests: [ + { + original: { + name: "unary", + expr: "math.greatest(5u)", + value: { uint64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@max(\n 5u~uint\n)~uint^math_@max_uint", + type: "uint", + }, + { + original: { + name: "binary_same_args", + expr: "math.greatest(1u, 1u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint", + type: "uint", + }, + { + original: { + name: "binary_with_decimal", + expr: "math.greatest(1u, 1.0) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n 1u~uint,\n 1~double\n )~dyn^math_@max_uint_double,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_with_int", + expr: "math.greatest(1u, 1) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n 1u~uint,\n 1~int\n )~dyn^math_@max_uint_int,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_first_arg_greater", + expr: "math.greatest(5u, -7)", + value: { uint64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 5u^#*expr.Constant_Uint64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 5u~uint,\n -7~int\n)~dyn^math_@max_uint_int", + type: "dyn", + }, + { + original: { + name: "binary_second_arg_greater", + expr: "math.greatest(-3, 3u)", + value: { uint64Value: "3" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n -3^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n -3~int,\n 3u~uint\n)~dyn^math_@max_int_uint", + type: "dyn", + }, + { + original: { + name: "binary_first_arg_uint_max", + expr: "math.greatest(18446744073709551615u, 1u)", + value: { uint64Value: "18446744073709551615" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@max_uint_uint", + type: "uint", + }, + { + original: { + name: "binary_second_arg_uint_max", + expr: "math.greatest(1u, 18446744073709551615u)", + value: { uint64Value: "18446744073709551615" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@max(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@max_uint_uint", + type: "uint", + }, + { + original: { + name: "ternary_same_args", + expr: "math.greatest(1u, 1u, 1u) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_decimal", + expr: "math.greatest(1u, 1.0, 1.0) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_int", + expr: "math.greatest(1u, 1, 1) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_first_arg_greatest", + expr: "math.greatest(10u, 1u, 3u) == 10u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 10u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 10u~uint,\n 1u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_third_arg_greatest", + expr: "math.greatest(1u, 3u, 10u) == 10u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 1u~uint,\n 3u~uint,\n 10u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 10u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_int_max", + expr: "math.greatest(18446744073709551615u, 1u, 5u) == 18446744073709551615u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed", + expr: "math.greatest(5.4, 10, 3u, -5.0, 18446744073709551615u) == 18446744073709551615u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 18446744073709551615u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_array", + expr: "math.greatest([5.4, 10u, 3u, -5.0, 3.5]) == 10u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_dyn_array", + expr: "math.greatest([dyn(5.4), dyn(10u), dyn(3u), dyn(-5.0), dyn(3.5)]) == 10u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.greatest(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 10u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@max(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@max_list_double|math_@max_list_int|math_@max_list_uint,\n 10u~uint\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "least_int_result", + tests: [ + { + original: { + name: "unary_negative", + expr: "math.least(-5)", + value: { int64Value: "-5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n -5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@min(\n -5~int\n)~int^math_@min_int", + type: "int", + }, + { + original: { + name: "unary_positive", + expr: "math.least(5)", + value: { int64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@min(\n 5~int\n)~int^math_@min_int", + type: "int", + }, + { + original: { + name: "binary_same_args", + expr: "math.least(1, 1)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1~int,\n 1~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "binary_with_decimal", + expr: "math.least(1, 1.0) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n 1~int,\n 1~double\n )~dyn^math_@min_int_double,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_with_uint", + expr: "math.least(1, 1u) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_first_arg_least", + expr: "math.least(-3, 3)", + value: { int64Value: "-3" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n -3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n -3~int,\n 3~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "binary_second_arg_least", + expr: "math.least(5, -7)", + value: { int64Value: "-7" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 5^#*expr.Constant_Int64Value#,\n -7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 5~int,\n -7~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "binary_first_arg_int_max", + expr: "math.least(9223372036854775807, 1)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 9223372036854775807~int,\n 1~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "binary_second_arg_int_max", + expr: "math.least(1, 9223372036854775807)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1~int,\n 9223372036854775807~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "binary_first_arg_int_min", + expr: "math.least(-9223372036854775808, 1)", + value: { int64Value: "-9223372036854775808" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n -9223372036854775808~int,\n 1~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "binary_second_arg_int_min", + expr: "math.least(1, -9223372036854775808)", + value: { int64Value: "-9223372036854775808" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1~int,\n -9223372036854775808~int\n)~int^math_@min_int_int", + type: "int", + }, + { + original: { + name: "ternary_same_args", + expr: "math.least(1, 1, 1) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1~int,\n 1~int,\n 1~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_decimal", + expr: "math.least(1, 1.0, 1.0) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1~int,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_uint", + expr: "math.least(1, 1u, 1u) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1~int,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_first_arg_least", + expr: "math.least(0, 1, 3) == 0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 0~int,\n 1~int,\n 3~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_third_arg_least", + expr: "math.least(1, 3, 0) == 0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1~int,\n 3~int,\n 0~int\n ]~list(int)\n )~int^math_@min_list_int,\n 0~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_negatives", + expr: "math.least(-1, -2, -3) == -3", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#,\n -3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n -1~int,\n -2~int,\n -3~int\n ]~list(int)\n )~int^math_@min_list_int,\n -3~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_int_max", + expr: "math.least(9223372036854775807, 1, 5) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 9223372036854775807^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 9223372036854775807~int,\n 1~int,\n 5~int\n ]~list(int)\n )~int^math_@min_list_int,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_int_min", + expr: "math.least(-9223372036854775808, -1, -5) == -9223372036854775808", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -9223372036854775808^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n -9223372036854775808~int,\n -1~int,\n -5~int\n ]~list(int)\n )~int^math_@min_list_int,\n -9223372036854775808~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed", + expr: "math.least(5.4, 10, 3u, -5.0, 9223372036854775807) == -5.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 9223372036854775807^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 9223372036854775807~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_array", + expr: "math.least([5.4, 10, 3u, -5.0, 3.5]) == -5.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_dyn_array", + expr: "math.least([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10~int\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "least_double_result", + tests: [ + { + original: { + name: "unary_negative", + expr: "math.least(-5.5)", + value: { doubleValue: -5.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n -5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n -5.5~double\n)~double^math_@min_double", + type: "double", + }, + { + original: { + name: "unary_positive", + expr: "math.least(5.5)", + value: { doubleValue: 5.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@min(\n 5.5~double\n)~double^math_@min_double", + type: "double", + }, + { + original: { + name: "binary_same_args", + expr: "math.least(1.5, 1.5)", + value: { doubleValue: 1.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1.5~double,\n 1.5~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "binary_with_int", + expr: "math.least(1.0, 1) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n 1~double,\n 1~int\n )~dyn^math_@min_double_int,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_with_uint", + expr: "math.least(1, 1u) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_Int64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n 1~int,\n 1u~uint\n )~dyn^math_@min_int_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_first_arg_least", + expr: "math.least(-3.5, 3.5)", + value: { doubleValue: -3.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n -3.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n -3.5~double,\n 3.5~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "binary_second_arg_least", + expr: "math.least(5.5, -7.5)", + value: { doubleValue: -7.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 5.5^#*expr.Constant_DoubleValue#,\n -7.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 5.5~double,\n -7.5~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "binary_first_arg_double_max", + expr: "math.least(1.797693e308, 1.5)", + value: { doubleValue: 1.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "binary_second_arg_double_max", + expr: "math.least(1.5, 1.797693e308)", + value: { doubleValue: 1.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1.5~double,\n 1.797693e+308~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "binary_first_arg_double_min", + expr: "math.least(-1.797693e308, 1.5)", + value: { doubleValue: -1.797693e308 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n -1.797693e+308~double,\n 1.5~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "binary_second_arg_double_min", + expr: "math.least(1.5, -1.797693e308)", + value: { doubleValue: -1.797693e308 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1.5~double,\n -1.797693e+308~double\n)~double^math_@min_double_double", + type: "double", + }, + { + original: { + name: "ternary_same_args", + expr: "math.least(1.5, 1.5, 1.5) == 1.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1.5~double,\n 1.5~double,\n 1.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 1.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_int", + expr: "math.least(1.0, 1, 1) == 1.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1~double,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_uint", + expr: "math.least(1.0, 1u, 1u) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1^#*expr.Constant_DoubleValue#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1~double,\n 1u~uint,\n 1u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_first_arg_least", + expr: "math.least(0.5, 1.5, 3.5) == 0.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 0.5^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 0.5~double,\n 1.5~double,\n 3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_third_arg_least", + expr: "math.least(1.5, 3.5, 0.5) == 0.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#,\n 0.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 0.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1.5~double,\n 3.5~double,\n 0.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n 0.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_negatives", + expr: "math.least(-1.5, -2.5, -3.5) == -3.5", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.5^#*expr.Constant_DoubleValue#,\n -2.5^#*expr.Constant_DoubleValue#,\n -3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -3.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n -1.5~double,\n -2.5~double,\n -3.5~double\n ]~list(double)\n )~double^math_@min_list_double,\n -3.5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_double_max", + expr: "math.least(1.797693e308, 1, 5) == 1", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1.797693e+308^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1.797693e+308~double,\n 1~int,\n 5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_double_min", + expr: "math.least(-1.797693e308, -1, -5) == -1.797693e308", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n -1.797693e+308^#*expr.Constant_DoubleValue#,\n -1^#*expr.Constant_Int64Value#,\n -5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1.797693e+308^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n -1.797693e+308~double,\n -1~int,\n -5~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -1.797693e+308~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed", + expr: "math.least(5.4, 10, 3u, -5.0, 1.797693e308) == -5.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 1.797693e+308^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n -5~double,\n 1.797693e+308~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_array", + expr: "math.least([5.4, 10.5, 3u, -5.0, 3.5]) == -5.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10.5^#*expr.Constant_DoubleValue#,\n 3u^#*expr.Constant_Uint64Value#,\n -5^#*expr.Constant_DoubleValue#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 5.4~double,\n 10.5~double,\n 3u~uint,\n -5~double,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_dyn_array", + expr: "math.least([dyn(5.4), dyn(10.5), dyn(3u), dyn(-5.0), dyn(3.5)]) == -5.0", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n -5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n -5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10.5~double\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n -5~double\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n -5~double\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "least_uint_result", + tests: [ + { + original: { + name: "unary", + expr: "math.least(5u)", + value: { uint64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.@min(\n 5u~uint\n)~uint^math_@min_uint", + type: "uint", + }, + { + original: { + name: "binary_same_args", + expr: "math.least(1u, 1u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint", + type: "uint", + }, + { + original: { + name: "binary_with_decimal", + expr: "math.least(1u, 1.0) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n 1u~uint,\n 1~double\n )~dyn^math_@min_uint_double,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_with_int", + expr: "math.least(1u, 1) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n 1u~uint,\n 1~int\n )~dyn^math_@min_uint_int,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "binary_first_arg_least", + expr: "math.least(1u, 3u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1u~uint,\n 3u~uint\n)~uint^math_@min_uint_uint", + type: "uint", + }, + { + original: { + name: "binary_second_arg_least", + expr: "math.least(5u, 2u)", + value: { uint64Value: "2" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 5u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 5u~uint,\n 2u~uint\n)~uint^math_@min_uint_uint", + type: "uint", + }, + { + original: { + name: "binary_first_arg_uint_max", + expr: "math.least(18446744073709551615u, 1u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 18446744073709551615u~uint,\n 1u~uint\n)~uint^math_@min_uint_uint", + type: "uint", + }, + { + original: { + name: "binary_second_arg_uint_max", + expr: "math.least(1u, 18446744073709551615u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.@min(\n 1u~uint,\n 18446744073709551615u~uint\n)~uint^math_@min_uint_uint", + type: "uint", + }, + { + original: { + name: "ternary_same_args", + expr: "math.least(1u, 1u, 1u) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1u~uint,\n 1u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_decimal", + expr: "math.least(1u, 1.0, 1.0) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_DoubleValue#,\n 1^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1u~uint,\n 1~double,\n 1~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_with_int", + expr: "math.least(1u, 1, 1) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1u~uint,\n 1~int,\n 1~int\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_first_arg_least", + expr: "math.least(1u, 10u, 3u) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 1u^#*expr.Constant_Uint64Value#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 1u~uint,\n 10u~uint,\n 3u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_third_arg_least", + expr: "math.least(10u, 3u, 1u) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 10u~uint,\n 3u~uint,\n 1u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_uint_max", + expr: "math.least(18446744073709551615u, 1u, 5u) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 18446744073709551615u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 5u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 18446744073709551615u~uint,\n 1u~uint,\n 5u~uint\n ]~list(uint)\n )~uint^math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed", + expr: "math.least(5.4, 10, 3u, 1u, 18446744073709551615u) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n 5.4^#*expr.Constant_DoubleValue#,\n 10^#*expr.Constant_Int64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 18446744073709551615u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 5.4~double,\n 10~int,\n 3u~uint,\n 1u~uint,\n 18446744073709551615u~uint\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_array", + expr: "math.least([5.4, 10u, 3u, 1u, 3.5]) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n 5.4^#*expr.Constant_DoubleValue#,\n 10u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#,\n 1u^#*expr.Constant_Uint64Value#,\n 3.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n 5.4~double,\n 10u~uint,\n 3u~uint,\n 1u~uint,\n 3.5~double\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "quaternary_mixed_dyn_array", + expr: "math.least([dyn(5.4), dyn(10u), dyn(3u), dyn(1u), dyn(3.5)]) == 1u", + }, + ast: "_==_(\n math^#*expr.Expr_IdentExpr#.least(\n [\n dyn(\n 5.4^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 10u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 1u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n math.@min(\n [\n dyn(\n 5.4~double\n )~dyn^to_dyn,\n dyn(\n 10u~uint\n )~dyn^to_dyn,\n dyn(\n 3u~uint\n )~dyn^to_dyn,\n dyn(\n 1u~uint\n )~dyn^to_dyn,\n dyn(\n 3.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n )~dyn^math_@min_list_double|math_@min_list_int|math_@min_list_uint,\n 1u~uint\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "ceil", + tests: [ + { + original: { + name: "negative", + expr: "math.ceil(-1.2)", + value: { doubleValue: -1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.ceil(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.ceil(\n -1.2~double\n)~double^math_ceil_double", + type: "double", + }, + { + original: { + name: "positive", + expr: "math.ceil(1.2)", + value: { doubleValue: 2 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.ceil(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.ceil(\n 1.2~double\n)~double^math_ceil_double", + type: "double", + }, + { + original: { + name: "dyn_error", + expr: "math.ceil(dyn(1))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.ceil(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.ceil(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_ceil_double", + type: "double", + }, + ], + }, + { + name: "floor", + tests: [ + { + original: { + name: "negative", + expr: "math.floor(-1.2)", + value: { doubleValue: -2 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.floor(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.floor(\n -1.2~double\n)~double^math_floor_double", + type: "double", + }, + { + original: { + name: "positive", + expr: "math.floor(1.2)", + value: { doubleValue: 1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.floor(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.floor(\n 1.2~double\n)~double^math_floor_double", + type: "double", + }, + { + original: { + name: "dyn_error", + expr: "math.floor(dyn(1))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.floor(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.floor(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_floor_double", + type: "double", + }, + ], + }, + { + name: "round", + tests: [ + { + original: { + name: "negative_down", + expr: "math.round(-1.6)", + value: { doubleValue: -2 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.round(\n -1.6^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.round(\n -1.6~double\n)~double^math_round_double", + type: "double", + }, + { + original: { + name: "negative_up", + expr: "math.round(-1.4)", + value: { doubleValue: -1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.round(\n -1.4^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.round(\n -1.4~double\n)~double^math_round_double", + type: "double", + }, + { + original: { + name: "negative_mid", + expr: "math.round(-1.5)", + value: { doubleValue: -2 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.round(\n -1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.round(\n -1.5~double\n)~double^math_round_double", + type: "double", + }, + { + original: { + name: "positive_down", + expr: "math.round(1.2)", + value: { doubleValue: 1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.round(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.round(\n 1.2~double\n)~double^math_round_double", + type: "double", + }, + { + original: { + name: "positive_up", + expr: "math.round(1.5)", + value: { doubleValue: 2 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.round(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.round(\n 1.5~double\n)~double^math_round_double", + type: "double", + }, + { + original: { + name: "nan", + expr: "math.isNaN(math.round(0.0/0.0))", + }, + ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.round(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isNaN(\n math.round(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_round_double\n)~bool^math_isNaN_double", + type: "bool", + }, + { + original: { + name: "dyn_error", + expr: "math.round(dyn(1))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.round(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.round(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_round_double", + type: "double", + }, + ], + }, + { + name: "trunc", + tests: [ + { + original: { + name: "negative", + expr: "math.trunc(-1.2)", + value: { doubleValue: -1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.trunc(\n -1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.trunc(\n -1.2~double\n)~double^math_trunc_double", + type: "double", + }, + { + original: { + name: "positive", + expr: "math.trunc(1.2)", + value: { doubleValue: 1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.trunc(\n 1.2^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.trunc(\n 1.2~double\n)~double^math_trunc_double", + type: "double", + }, + { + original: { + name: "nan", + expr: "math.isNaN(math.trunc(0.0/0.0))", + }, + ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n math^#*expr.Expr_IdentExpr#.trunc(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isNaN(\n math.trunc(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~double^math_trunc_double\n)~bool^math_isNaN_double", + type: "bool", + }, + { + original: { + name: "dyn_error", + expr: "math.trunc(dyn(1))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.trunc(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.trunc(\n dyn(\n 1~int\n )~dyn^to_dyn\n)~double^math_trunc_double", + type: "double", + }, + ], + }, + { + name: "abs", + tests: [ + { + original: { + name: "uint", + expr: "math.abs(1u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.abs(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.abs(\n 1u~uint\n)~uint^math_abs_uint", + type: "uint", + }, + { + original: { + name: "positive_int", + expr: "math.abs(1)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.abs(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.abs(\n 1~int\n)~int^math_abs_int", + type: "int", + }, + { + original: { + name: "negative_int", + expr: "math.abs(-11)", + value: { int64Value: "11" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.abs(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.abs(\n -11~int\n)~int^math_abs_int", + type: "int", + }, + { + original: { + name: "positive_double", + expr: "math.abs(1.5)", + value: { doubleValue: 1.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.abs(\n 1.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.abs(\n 1.5~double\n)~double^math_abs_double", + type: "double", + }, + { + original: { + name: "negative_double", + expr: "math.abs(-11.5)", + value: { doubleValue: 11.5 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.abs(\n -11.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.abs(\n -11.5~double\n)~double^math_abs_double", + type: "double", + }, + { + original: { + name: "int_overflow", + expr: "math.abs(-9223372036854775808)", + evalError: { errors: [{ message: "overflow" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.abs(\n -9223372036854775808^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.abs(\n -9223372036854775808~int\n)~int^math_abs_int", + type: "int", + }, + ], + }, + { + name: "sign", + tests: [ + { + original: { + name: "positive_uint", + expr: "math.sign(100u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n 100u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n 100u~uint\n)~uint^math_sign_uint", + type: "uint", + }, + { + original: { + name: "zero_uint", + expr: "math.sign(0u)", + value: { uint64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n 0u~uint\n)~uint^math_sign_uint", + type: "uint", + }, + { + original: { + name: "positive_int", + expr: "math.sign(100)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n 100^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n 100~int\n)~int^math_sign_int", + type: "int", + }, + { + original: { + name: "negative_int", + expr: "math.sign(-11)", + value: { int64Value: "-1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n -11^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n -11~int\n)~int^math_sign_int", + type: "int", + }, + { + original: { + name: "zero_int", + expr: "math.sign(0)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n 0~int\n)~int^math_sign_int", + type: "int", + }, + { + original: { + name: "positive_double", + expr: "math.sign(100.5)", + value: { doubleValue: 1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n 100.5^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.sign(\n 100.5~double\n)~double^math_sign_double", + type: "double", + }, + { + original: { + name: "negative_double", + expr: "math.sign(-32.0)", + value: { doubleValue: -1 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n -32^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n -32~double\n)~double^math_sign_double", + type: "double", + }, + { + original: { + name: "zero_double", + expr: "math.sign(0.0)", + value: { doubleValue: 0 }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n 0^#*expr.Constant_DoubleValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.sign(\n 0~double\n)~double^math_sign_double", + type: "double", + }, + { + original: { + name: "dyn_error", + expr: "math.sign(dyn(true))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.sign(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.sign(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~dyn^math_sign_double|math_sign_int|math_sign_uint", + type: "dyn", + }, + ], + }, + { + name: "isNaN", + tests: [ + { + original: { name: "true", expr: "math.isNaN(0.0/0.0)" }, + ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isNaN(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n)~bool^math_isNaN_double", + type: "bool", + }, + { + original: { name: "false", expr: "!math.isNaN(1.0/0.0)" }, + ast: "!_(\n math^#*expr.Expr_IdentExpr#.isNaN(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "!_(\n math.isNaN(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isNaN_double\n)~bool^logical_not", + type: "bool", + }, + { + original: { + name: "dyn_error", + expr: "math.isNaN(dyn(true))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.isNaN(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isNaN(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isNaN_double", + type: "bool", + }, + ], + }, + { + name: "isInf", + tests: [ + { + original: { name: "true", expr: "math.isInf(1.0/0.0)" }, + ast: "math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isInf(\n _/_(\n 1~double,\n 0~double\n )~double^divide_double\n)~bool^math_isInf_double", + type: "bool", + }, + { + original: { name: "false", expr: "!math.isInf(0.0/0.0)" }, + ast: "!_(\n math^#*expr.Expr_IdentExpr#.isInf(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "!_(\n math.isInf(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isInf_double\n)~bool^logical_not", + type: "bool", + }, + { + original: { + name: "dyn_error", + expr: "math.isInf(dyn(true))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.isInf(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isInf(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isInf_double", + type: "bool", + }, + ], + }, + { + name: "isFinite", + tests: [ + { + original: { name: "true", expr: "math.isFinite(1.0/1.5)" }, + ast: "math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 1^#*expr.Constant_DoubleValue#,\n 1.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isFinite(\n _/_(\n 1~double,\n 1.5~double\n )~double^divide_double\n)~bool^math_isFinite_double", + type: "bool", + }, + { + original: { name: "false_nan", expr: "!math.isFinite(0.0/0.0)" }, + ast: "!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n 0^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "!_(\n math.isFinite(\n _/_(\n 0~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not", + type: "bool", + }, + { + original: { name: "false_inf", expr: "!math.isFinite(-1.0/0.0)" }, + ast: "!_(\n math^#*expr.Expr_IdentExpr#.isFinite(\n _/_(\n -1^#*expr.Constant_DoubleValue#,\n 0^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "!_(\n math.isFinite(\n _/_(\n -1~double,\n 0~double\n )~double^divide_double\n )~bool^math_isFinite_double\n)~bool^logical_not", + type: "bool", + }, + { + original: { + name: "dyn_error", + expr: "math.isFinite(dyn(true))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.isFinite(\n dyn(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.isFinite(\n dyn(\n true~bool\n )~dyn^to_dyn\n)~bool^math_isFinite_double", + type: "bool", + }, + ], + }, + { + name: "bit_and", + tests: [ + { + original: { + name: "int_int_non_intersect", + expr: "math.bitAnd(1, 2)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitAnd(\n 1~int,\n 2~int\n)~int^math_bitAnd_int_int", + type: "int", + }, + { + original: { + name: "int_int_intersect", + expr: "math.bitAnd(1, 3)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitAnd(\n 1~int,\n 3~int\n)~int^math_bitAnd_int_int", + type: "int", + }, + { + original: { + name: "int_int_intersect_neg", + expr: "math.bitAnd(1, -1)", + value: { int64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1^#*expr.Constant_Int64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitAnd(\n 1~int,\n -1~int\n)~int^math_bitAnd_int_int", + type: "int", + }, + { + original: { + name: "uint_uint_non_intersect", + expr: "math.bitAnd(1u, 2u)", + value: { uint64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 2u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitAnd(\n 1u~uint,\n 2u~uint\n)~uint^math_bitAnd_uint_uint", + type: "uint", + }, + { + original: { + name: "uint_uint_intersect", + expr: "math.bitAnd(1u, 3u)", + value: { uint64Value: "1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitAnd(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitAnd(\n 1u~uint,\n 3u~uint\n)~uint^math_bitAnd_uint_uint", + type: "uint", + }, + { + original: { + name: "int_dyn_error", + expr: "math.bitAnd(2u, dyn(''))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: 'math^#*expr.Expr_IdentExpr#.bitAnd(\n 2u^#*expr.Constant_Uint64Value#,\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'math.bitAnd(\n 2u~uint,\n dyn(\n ""~string\n )~dyn^to_dyn\n)~uint^math_bitAnd_uint_uint', + type: "uint", + }, + ], + }, + { + name: "bit_or", + tests: [ + { + original: { + name: "int_int_positive", + expr: "math.bitOr(1, 2)", + value: { int64Value: "3" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitOr(\n 1~int,\n 2~int\n)~int^math_bitOr_int_int", + type: "int", + }, + { + original: { + name: "int_int_positive_negative", + expr: "math.bitOr(4, -2)", + value: { int64Value: "-2" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitOr(\n 4~int,\n -2~int\n)~int^math_bitOr_int_int", + type: "int", + }, + { + original: { + name: "uint_uint", + expr: "math.bitOr(1u, 4u)", + value: { uint64Value: "5" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n 1u^#*expr.Constant_Uint64Value#,\n 4u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitOr(\n 1u~uint,\n 4u~uint\n)~uint^math_bitOr_uint_uint", + type: "uint", + }, + { + original: { + name: "dyn_int_error", + expr: "math.bitOr(dyn(1.2), 1)", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitOr(\n dyn(\n 1.2^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitOr(\n dyn(\n 1.2~double\n )~dyn^to_dyn,\n 1~int\n)~int^math_bitOr_int_int", + type: "int", + }, + ], + }, + { + name: "bit_xor", + tests: [ + { + original: { + name: "int_int_positive", + expr: "math.bitXor(1, 3)", + value: { int64Value: "2" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n 1^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitXor(\n 1~int,\n 3~int\n)~int^math_bitXor_int_int", + type: "int", + }, + { + original: { + name: "int_int_positive_negative", + expr: "math.bitXor(4, -2)", + value: { int64Value: "-6" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n 4^#*expr.Constant_Int64Value#,\n -2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitXor(\n 4~int,\n -2~int\n)~int^math_bitXor_int_int", + type: "int", + }, + { + original: { + name: "uint_uint", + expr: "math.bitXor(1u, 3u)", + value: { uint64Value: "2" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n 1u^#*expr.Constant_Uint64Value#,\n 3u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitXor(\n 1u~uint,\n 3u~uint\n)~uint^math_bitXor_uint_uint", + type: "uint", + }, + { + original: { + name: "dyn_dyn_error", + expr: "math.bitXor(dyn([]), dyn([1]))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitXor(\n dyn(\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n dyn(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitXor(\n dyn(\n []~list(dyn)\n )~dyn^to_dyn,\n dyn(\n [\n 1~int\n ]~list(int)\n )~dyn^to_dyn\n)~dyn^math_bitXor_int_int|math_bitXor_uint_uint", + type: "dyn", + }, + ], + }, + { + name: "bit_not", + tests: [ + { + original: { + name: "int_positive", + expr: "math.bitNot(1)", + value: { int64Value: "-2" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.bitNot(\n 1~int\n)~int^math_bitNot_int_int", + type: "int", + }, + { + original: { + name: "int_negative", + expr: "math.bitNot(-1)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.bitNot(\n -1~int\n)~int^math_bitNot_int_int", + type: "int", + }, + { + original: { + name: "int_zero", + expr: "math.bitNot(0)", + value: { int64Value: "-1" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "math.bitNot(\n 0~int\n)~int^math_bitNot_int_int", + type: "int", + }, + { + original: { + name: "uint_positive", + expr: "math.bitNot(1u)", + value: { uint64Value: "18446744073709551614" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 1u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitNot(\n 1u~uint\n)~uint^math_bitNot_uint_uint", + type: "uint", + }, + { + original: { + name: "uint_zero", + expr: "math.bitNot(0u)", + value: { uint64Value: "18446744073709551615" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitNot(\n 0u^#*expr.Constant_Uint64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitNot(\n 0u~uint\n)~uint^math_bitNot_uint_uint", + type: "uint", + }, + { + original: { + name: "dyn_error", + expr: "math.bitNot(dyn(''))", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: 'math^#*expr.Expr_IdentExpr#.bitNot(\n dyn(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'math.bitNot(\n dyn(\n ""~string\n )~dyn^to_dyn\n)~dyn^math_bitNot_int_int|math_bitNot_uint_uint', + type: "dyn", + }, + ], + }, + { + name: "bit_shift_left", + tests: [ + { + original: { + name: "int", + expr: "math.bitShiftLeft(1, 2)", + value: { int64Value: "4" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n 1~int,\n 2~int\n)~int^math_bitShiftLeft_int_int", + type: "int", + }, + { + original: { + name: "int_large_shift", + expr: "math.bitShiftLeft(1, 200)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n 1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int", + type: "int", + }, + { + original: { + name: "int_negative_large_shift", + expr: "math.bitShiftLeft(-1, 200)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n -1^#*expr.Constant_Int64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n -1~int,\n 200~int\n)~int^math_bitShiftLeft_int_int", + type: "int", + }, + { + original: { + name: "uint", + expr: "math.bitShiftLeft(1u, 2)", + value: { uint64Value: "4" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n 1u~uint,\n 2~int\n)~uint^math_bitShiftLeft_uint_int", + type: "uint", + }, + { + original: { + name: "uint_large_shift", + expr: "math.bitShiftLeft(1u, 200)", + value: { uint64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n 1u~uint,\n 200~int\n)~uint^math_bitShiftLeft_uint_int", + type: "uint", + }, + { + original: { + name: "bad_shift", + expr: "math.bitShiftLeft(1u, -1)", + evalError: { errors: [{ message: "negative offset" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftLeft_uint_int", + type: "uint", + }, + { + original: { + name: "dyn_int_error", + expr: "math.bitShiftLeft(dyn(4.3), 1)", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftLeft(\n dyn(\n 4.3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftLeft(\n dyn(\n 4.3~double\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftLeft_int_int|math_bitShiftLeft_uint_int", + type: "dyn", + }, + ], + }, + { + name: "bit_shift_right", + tests: [ + { + original: { + name: "int", + expr: "math.bitShiftRight(1024, 2)", + value: { int64Value: "256" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n 1024~int,\n 2~int\n)~int^math_bitShiftRight_int_int", + type: "int", + }, + { + original: { + name: "int_large_shift", + expr: "math.bitShiftRight(1024, 64)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n 1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int", + type: "int", + }, + { + original: { + name: "int_negative", + expr: "math.bitShiftRight(-1024, 3)", + value: { int64Value: "2305843009213693824" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n -1024~int,\n 3~int\n)~int^math_bitShiftRight_int_int", + type: "int", + }, + { + original: { + name: "int_negative_large_shift", + expr: "math.bitShiftRight(-1024, 64)", + value: { int64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n -1024^#*expr.Constant_Int64Value#,\n 64^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n -1024~int,\n 64~int\n)~int^math_bitShiftRight_int_int", + type: "int", + }, + { + original: { + name: "uint", + expr: "math.bitShiftRight(1024u, 2)", + value: { uint64Value: "256" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n 1024u~uint,\n 2~int\n)~uint^math_bitShiftRight_uint_int", + type: "uint", + }, + { + original: { + name: "uint_large_shift", + expr: "math.bitShiftRight(1024u, 200)", + value: { uint64Value: "0" }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1024u^#*expr.Constant_Uint64Value#,\n 200^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n 1024u~uint,\n 200~int\n)~uint^math_bitShiftRight_uint_int", + type: "uint", + }, + { + original: { + name: "bad_shift", + expr: "math.bitShiftRight(1u, -1)", + evalError: { errors: [{ message: "negative offset" }] }, + }, + ast: "math^#*expr.Expr_IdentExpr#.bitShiftRight(\n 1u^#*expr.Constant_Uint64Value#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "math.bitShiftRight(\n 1u~uint,\n -1~int\n)~uint^math_bitShiftRight_uint_int", + type: "uint", + }, + { + original: { + name: "dyn_int_error", + expr: "math.bitShiftRight(dyn(b'123'), 1)", + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: 'math^#*expr.Expr_IdentExpr#.bitShiftRight(\n dyn(\n b"123"^#*expr.Constant_BytesValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'math.bitShiftRight(\n dyn(\n b"123"~bytes\n )~dyn^to_dyn,\n 1~int\n)~dyn^math_bitShiftRight_int_int|math_bitShiftRight_uint_int', + type: "dyn", + }, + ], + }, + ], + }, + { + name: "namespace", + suites: [ + { + name: "qualified", + tests: [ + { + original: { + name: "self_eval_qualified_lookup", + expr: "x.y", + typeEnv: [ + { name: "x.y", ident: { type: { primitive: "BOOL" } } }, + ], + bindings: { "x.y": { value: { boolValue: true } } }, + value: { boolValue: true }, + }, + ast: "x^#*expr.Expr_IdentExpr#.y^#*expr.Expr_SelectExpr#", + checkedAst: "x.y~bool^x.y", + type: "bool", + }, + ], + }, + { + name: "namespace", + tests: [ + { + original: { + name: "self_eval_container_lookup", + expr: "y", + typeEnv: [ + { name: "x.y", ident: { type: { primitive: "BOOL" } } }, + { name: "y", ident: { type: { primitive: "STRING" } } }, + ], + container: "x", + bindings: { + "x.y": { value: { boolValue: true } }, + y: { value: { stringValue: "false" } }, + }, + value: { boolValue: true }, + }, + ast: "y^#*expr.Expr_IdentExpr#", + checkedAst: "x.y~bool^x.y", + type: "bool", + }, + { + original: { + name: "self_eval_container_lookup_unchecked", + expr: "y", + disableCheck: true, + typeEnv: [ + { name: "x.y", ident: { type: { primitive: "BOOL" } } }, + { name: "y", ident: { type: { primitive: "BOOL" } } }, + ], + container: "x", + bindings: { + "x.y": { value: { boolValue: true } }, + y: { value: { boolValue: false } }, + }, + value: { boolValue: true }, + }, + ast: "y^#*expr.Expr_IdentExpr#", + checkedAst: "x.y~bool^x.y", + type: "bool", + }, + ], + }, + ], + }, + { + name: "optionals", + suites: [ + { + name: "optionals", + tests: [ + { + original: { + name: "null", + expr: "optional.of(null).hasValue()", + value: { boolValue: true }, + }, + ast: "optional^#*expr.Expr_IdentExpr#.of(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", + checkedAst: + "optional.of(\n null~null\n)~optional_type(null)^optional_of.hasValue()~bool^optional_hasValue", + type: "bool", + }, + { + original: { + name: "null_non_zero_value", + expr: "optional.ofNonZeroValue(null).hasValue()", + value: { boolValue: false }, + }, + ast: "optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", + checkedAst: + "optional.ofNonZeroValue(\n null~null\n)~optional_type(null)^optional_ofNonZeroValue.hasValue()~bool^optional_hasValue", + type: "bool", + }, + { + original: { + name: "none_or_none_or_value", + expr: "optional.none().or(optional.none()).orValue(42)", + value: { int64Value: "42" }, + }, + ast: "optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "optional.none()~optional_type(int)^optional_none.or(\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^optional_or_optional.orValue(\n 42~int\n)~int^optional_orValue_value", + type: "int", + }, + { + original: { + name: "none_optMap_hasValue", + expr: "optional.none().optMap(y, y + 1).hasValue()", + value: { boolValue: false }, + }, + ast: "optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n optional.none()~optional_type(dyn)^optional_none.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.none()~optional_type(int)^optional_none.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.hasValue()~bool^optional_hasValue", + type: "bool", + }, + { + original: { + name: "empty_map_optFlatMap_hasValue", + expr: "{}.?key.optFlatMap(k, k.?subkey).hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: empty_map_optFlatMap_hasValue:1:3: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ..^\nERROR: empty_map_optFlatMap_hasValue:1:24: unsupported syntax '.?'\n | {}.?key.optFlatMap(k, k.?subkey).hasValue()\n | .......................^", + }, + { + original: { + name: "map_empty_submap_optFlatMap_hasValue", + expr: "{'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: map_empty_submap_optFlatMap_hasValue:1:12: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ...........^\nERROR: map_empty_submap_optFlatMap_hasValue:1:33: unsupported syntax '.?'\n | {'key': {}}.?key.optFlatMap(k, k.?subkey).hasValue()\n | ................................^", + }, + { + original: { + name: "map_null_entry_hasValue", + expr: "{'null_key': dyn(null)}.?null_key.hasValue()", + value: { boolValue: true }, + }, + error: + "ERROR: map_null_entry_hasValue:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.hasValue()\n | .......................^", + }, + { + original: { + name: "map_null_entry_no_such_key", + expr: "{'null_key': dyn(null)}.?null_key.invalid.hasValue()", + evalError: { errors: [{ message: "no such key" }] }, + }, + error: + "ERROR: map_null_entry_no_such_key:1:24: unsupported syntax '.?'\n | {'null_key': dyn(null)}.?null_key.invalid.hasValue()\n | .......................^", + }, + { + original: { + name: "map_absent_key_absent_field_none", + expr: "{true: dyn(0)}[?false].absent.hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: map_absent_key_absent_field_none:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?false].absent.hasValue()\n | ..............^", + }, + { + original: { + name: "map_present_key_invalid_field", + expr: "{true: dyn(0)}[?true].absent.hasValue()", + evalError: { errors: [{ message: "no such key" }] }, + }, + error: + "ERROR: map_present_key_invalid_field:1:15: unsupported syntax '[?'\n | {true: dyn(0)}[?true].absent.hasValue()\n | ..............^", + }, + { + original: { + name: "map_undefined_entry_hasValue", + expr: "{}.?null_key.invalid.hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: map_undefined_entry_hasValue:1:3: unsupported syntax '.?'\n | {}.?null_key.invalid.hasValue()\n | ..^", + }, + { + original: { + name: "map_submap_subkey_optFlatMap_value", + expr: "{'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()", + value: { stringValue: "subvalue" }, + }, + error: + "ERROR: map_submap_subkey_optFlatMap_value:1:32: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ...............................^\nERROR: map_submap_subkey_optFlatMap_value:1:53: unsupported syntax '.?'\n | {'key': {'subkey': 'subvalue'}}.?key.optFlatMap(k, k.?subkey).value()\n | ....................................................^", + }, + { + original: { + name: "map_submap_optFlatMap_value", + expr: "{'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()", + value: { stringValue: "" }, + }, + error: + "ERROR: map_submap_optFlatMap_value:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | .......................^\nERROR: map_submap_optFlatMap_value:1:45: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, k.?subkey).value()\n | ............................................^", + }, + { + original: { + name: "map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue", + expr: "{'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: map_optindex_optFlatMap_optional_ofNonZeroValue_hasValue:1:24: unsupported syntax '.?'\n | {'key': {'subkey': ''}}.?key.optFlatMap(k, optional.ofNonZeroValue(k.subkey)).hasValue()\n | .......................^", + }, + { + original: { + name: "optional_of_optMap_value", + expr: "optional.of(42).optMap(y, y + 1).value()", + value: { int64Value: "43" }, + }, + ast: "optional^#*expr.Expr_IdentExpr#.of(\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.optMap(\n y^#*expr.Expr_IdentExpr#,\n _+_(\n y^#*expr.Expr_IdentExpr#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.hasValue()~bool^optional_hasValue,\n optional.of(\n __comprehension__(\n // Variable\n #unused,\n // Target\n []~list(dyn),\n // Accumulator\n y,\n // Init\n optional.of(\n 42~int\n )~optional_type(int)^optional_of.value()~int^optional_value,\n // LoopCondition\n false~bool,\n // LoopStep\n y~int^y,\n // Result\n _+_(\n y~int^y,\n 1~int\n )~int^add_int64)~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~optional_type(int)^conditional.value()~int^optional_value", + type: "int", + }, + { + original: { + name: "optional_ofNonZeroValue_or_optional_value", + expr: "optional.ofNonZeroValue(42).or(optional.of(20)).value() == 42", + value: { boolValue: true }, + }, + ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n 42^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n 20^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#.value()^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n optional.ofNonZeroValue(\n 42~int\n )~optional_type(int)^optional_ofNonZeroValue.or(\n optional.of(\n 20~int\n )~optional_type(int)^optional_of\n )~optional_type(int)^optional_or_optional.value()~int^optional_value,\n 42~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "ternary_optional_hasValue", + expr: "(has({}.x) ? optional.of({}.x) : optional.none()).hasValue()", + value: { boolValue: false }, + }, + ast: "_?_:_(\n {}^#*expr.Expr_StructExpr#.x~test-only~^#*expr.Expr_SelectExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n {}^#*expr.Expr_StructExpr#.x^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.hasValue()^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n {}~map(dyn, dyn).x~test-only~~bool,\n optional.of(\n {}~map(dyn, dyn).x~dyn\n )~optional_type(dyn)^optional_of,\n optional.none()~optional_type(dyn)^optional_none\n)~optional_type(dyn)^conditional.hasValue()~bool^optional_hasValue", + type: "bool", + }, + { + original: { + name: "map_optindex_hasValue", + expr: "{}.?x.hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: map_optindex_hasValue:1:3: unsupported syntax '.?'\n | {}.?x.hasValue()\n | ..^", + }, + { + original: { + name: "has_map_optindex", + expr: "has({}.?x.y)", + value: { boolValue: false }, + }, + error: + "ERROR: has_map_optindex:1:7: unsupported syntax '.?'\n | has({}.?x.y)\n | ......^", + }, + { + original: { + name: "has_map_optindex_field", + expr: "has({'x': {'y': 'z'}}.?x.y)", + value: { boolValue: true }, + }, + error: + "ERROR: has_map_optindex_field:1:22: unsupported syntax '.?'\n | has({'x': {'y': 'z'}}.?x.y)\n | .....................^", + }, + { + original: { + name: "type", + expr: "type(optional.none()) == optional_type", + value: { boolValue: true }, + }, + ast: "_==_(\n type(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional_type^#*expr.Expr_IdentExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n type(\n optional.none()~optional_type(dyn)^optional_none\n )~type(optional_type(dyn))^type,\n optional_type~type(optional_type)^optional_type\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "optional_chaining_1", + expr: "optional.ofNonZeroValue('').or(optional.of({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])).orValue('default value')", + value: { stringValue: "goodbye" }, + }, + ast: 'optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.or(\n optional^#*expr.Expr_IdentExpr#.of(\n _[_](\n {\n "c"^#*expr.Constant_StringValue#:{\n "dashed-index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n "dashed-index"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'optional.ofNonZeroValue(\n ""~string\n)~optional_type(string)^optional_ofNonZeroValue.or(\n optional.of(\n _[_](\n {\n "c"~string:{\n "dashed-index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n "dashed-index"~string\n )~string^index_map\n )~optional_type(string)^optional_of\n)~optional_type(string)^optional_or_optional.orValue(\n "default value"~string\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_2", + expr: "{'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')", + value: { stringValue: "goodbye" }, + }, + error: + "ERROR: optional_chaining_2:1:37: unsupported syntax '[?'\n | {'c': {'dashed-index': 'goodbye'}}.c[?'dashed-index'].orValue('default value')\n | ....................................^", + }, + { + original: { + name: "optional_chaining_3", + expr: "{'c': {}}.c[?'missing-index'].orValue('default value')", + value: { stringValue: "default value" }, + }, + error: + "ERROR: optional_chaining_3:1:12: unsupported syntax '[?'\n | {'c': {}}.c[?'missing-index'].orValue('default value')\n | ...........^", + }, + { + original: { + name: "optional_chaining_4", + expr: "optional.of({'c': {'index': 'goodbye'}}).c.index.orValue('default value')", + value: { stringValue: "goodbye" }, + }, + ast: 'optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.index^#*expr.Expr_SelectExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'optional.of(\n {\n "c"~string:{\n "index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string))\n)~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).index~optional_type(string).orValue(\n "default value"~string\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_5", + expr: "optional.of({'c': {}}).c.missing.or(optional.none()[0]).orValue('default value')", + value: { stringValue: "default value" }, + }, + ast: 'optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'optional.of(\n {\n "c"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.none()~optional_type(list(string))^optional_none,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n "default value"~string\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_6", + expr: "optional.of({'c': {}}).c.missing.or(optional.of(['list-value'])[0]).orValue('default value')", + value: { stringValue: "list-value" }, + }, + ast: 'optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing^#*expr.Expr_SelectExpr#.or(\n _[_](\n optional^#*expr.Expr_IdentExpr#.of(\n [\n "list-value"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'optional.of(\n {\n "c"~string:{}~map(dyn, string)\n }~map(string, map(dyn, string))\n)~optional_type(map(string, map(dyn, string)))^optional_of.c~optional_type(map(dyn, string)).missing~optional_type(string).or(\n _[_](\n optional.of(\n [\n "list-value"~string\n ]~list(string)\n )~optional_type(list(string))^optional_of,\n 0~int\n )~optional_type(string)^optional_list_index_int\n)~optional_type(string)^optional_or_optional.orValue(\n "default value"~string\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_7", + expr: "optional.of({'c': {'index': 'goodbye'}}).c['index'].orValue('default value')", + value: { stringValue: "goodbye" }, + }, + ast: '_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n "index"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n optional.of(\n {\n "c"~string:{\n "index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n "index"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n "default value"~string\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_8", + expr: "optional.of({'c': {}}).c['missing'].orValue('default value')", + value: { stringValue: "default value" }, + }, + ast: '_[_](\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#,\n "missing"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.orValue(\n "default value"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n optional.of(\n {\n "c"~string:{}~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)),\n "missing"~string\n)~optional_type(string)^optional_map_index_value.orValue(\n "default value"~string\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_9", + expr: "has(optional.of({'c': {'entry': 'hello world'}}).c) \u0026\u0026 !has(optional.of({'c': {'entry': 'hello world'}}).c.missing)", + value: { boolValue: true }, + }, + ast: '_\u0026\u0026_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "entry"^#*expr.Constant_StringValue#:"hello world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c~test-only~^#*expr.Expr_SelectExpr#,\n !_(\n optional^#*expr.Expr_IdentExpr#.of(\n {\n "c"^#*expr.Constant_StringValue#:{\n "entry"^#*expr.Constant_StringValue#:"hello world"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#.c^#*expr.Expr_SelectExpr#.missing~test-only~^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u0026\u0026_(\n optional.of(\n {\n "c"~string:{\n "entry"~string:"hello world"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~test-only~~bool,\n !_(\n optional.of(\n {\n "c"~string:{\n "entry"~string:"hello world"~string\n }~map(string, string)\n }~map(string, map(string, string))\n )~optional_type(map(string, map(string, string)))^optional_of.c~optional_type(map(string, string)).missing~test-only~~bool\n )~bool^logical_not\n)~bool^logical_and', + type: "bool", + }, + { + original: { + name: "optional_chaining_10", + expr: "optional.ofNonZeroValue({'c': {'dashed-index': 'goodbye'}}.a.z).orValue({'c': {'dashed-index': 'goodbye'}}.c['dashed-index'])", + evalError: { errors: [{ message: "no such key" }] }, + }, + ast: 'optional^#*expr.Expr_IdentExpr#.ofNonZeroValue(\n {\n "c"^#*expr.Constant_StringValue#:{\n "dashed-index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.a^#*expr.Expr_SelectExpr#.z^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#.orValue(\n _[_](\n {\n "c"^#*expr.Constant_StringValue#:{\n "dashed-index"^#*expr.Constant_StringValue#:"goodbye"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.c^#*expr.Expr_SelectExpr#,\n "dashed-index"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'optional.ofNonZeroValue(\n {\n "c"~string:{\n "dashed-index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string)).a~map(string, string).z~string\n)~optional_type(string)^optional_ofNonZeroValue.orValue(\n _[_](\n {\n "c"~string:{\n "dashed-index"~string:"goodbye"~string\n }~map(string, string)\n }~map(string, map(string, string)).c~map(string, string),\n "dashed-index"~string\n )~string^index_map\n)~string^optional_orValue_value', + type: "string", + }, + { + original: { + name: "optional_chaining_11", + expr: "{'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()", + value: { int64Value: "7" }, + }, + error: + "ERROR: optional_chaining_11:1:35: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ..................................^\nERROR: optional_chaining_11:1:84: unsupported syntax '.?'\n | {'c': {'dashed-index': 'goodbye'}}.?c.missing.or({'c': {'dashed-index': 'goodbye'}}.?c['dashed-index']).orValue('').size()\n | ...................................................................................^", + }, + { + original: { + name: "optional_chaining_12", + expr: "{?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "nested_map" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "map" }, + value: { + mapValue: { + entries: [ + { + key: { stringValue: "dashed-index" }, + value: { stringValue: "goodbye" }, + }, + ], + }, + }, + }, + ], + }, + }, + }, + ], + }, + }, + }, + error: + "ERROR: optional_chaining_12:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {'c': {'dashed-index': 'goodbye'}}.?c})}\n | .^", + }, + { + original: { + name: "optional_chaining_13", + expr: "{?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "singleton" }, + value: { boolValue: true }, + }, + ], + }, + }, + }, + error: + "ERROR: optional_chaining_13:1:2: unsupported syntax '?'\n | {?'nested_map': optional.ofNonZeroValue({?'map': {}.?c}), 'singleton': true}\n | .^", + }, + { + original: { + name: "optional_chaining_14", + expr: "[?{}.?c, ?optional.of(42), ?optional.none()]", + value: { listValue: { values: [{ int64Value: "42" }] } }, + }, + error: + "ERROR: optional_chaining_14:1:2: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .^\nERROR: optional_chaining_14:1:5: unsupported syntax '.?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ....^\nERROR: optional_chaining_14:1:10: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | .........^\nERROR: optional_chaining_14:1:28: unsupported syntax '?'\n | [?{}.?c, ?optional.of(42), ?optional.none()]\n | ...........................^", + }, + { + original: { + name: "optional_chaining_15", + expr: "[?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]", + value: { listValue: {} }, + }, + error: + "ERROR: optional_chaining_15:1:2: unsupported syntax '?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | .^\nERROR: optional_chaining_15:1:36: unsupported syntax '.?'\n | [?optional.ofNonZeroValue({'c': []}.?c.orValue(dyn({})))]\n | ...................................^", + }, + { + original: { + name: "optional_chaining_16", + expr: "optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: optional_chaining_16:1:26: unsupported syntax '?'\n | optional.ofNonZeroValue({?'nested_map': optional.ofNonZeroValue({?'map': optional.of({}).?c})}).hasValue()\n | .........................^", + }, + { + original: { + name: "has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field", + expr: "has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + error: + "ERROR: has_optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:18: unsupported syntax '?'\n | has(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}.single_double_wrapper)\n | .................^", + }, + { + original: { + name: "optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field", + expr: "optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + error: + "ERROR: optional_ofNonZeroValue_struct_optional_ofNonZeroValue_map_optindex_field:1:38: unsupported syntax '?'\n | optional.ofNonZeroValue(TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}).hasValue()\n | .....................................^", + }, + { + original: { + name: "struct_map_optindex_field", + expr: "TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string", + container: "cel.expr.conformance.proto2", + value: { mapValue: {} }, + }, + error: + "ERROR: struct_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {}}[?'nested']}.map_string_string\n | .............^", + }, + { + original: { + name: "struct_optional_ofNonZeroValue_map_optindex_field", + expr: "TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string", + container: "cel.expr.conformance.proto2", + value: { mapValue: {} }, + }, + error: + "ERROR: struct_optional_ofNonZeroValue_map_optindex_field:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: optional.ofNonZeroValue({'nested': {}}[?'nested'].orValue({}))}.map_string_string\n | .............^", + }, + { + original: { + name: "struct_map_optindex_field_nested", + expr: "TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string", + container: "cel.expr.conformance.proto2", + value: { + mapValue: { + entries: [ + { + key: { stringValue: "hello" }, + value: { stringValue: "world" }, + }, + ], + }, + }, + }, + error: + "ERROR: struct_map_optindex_field_nested:1:14: unsupported syntax '?'\n | TestAllTypes{?map_string_string: {'nested': {'hello': 'world'}}[?'nested']}.map_string_string\n | .............^", + }, + { + original: { + name: "struct_list_optindex_field", + expr: "TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string", + container: "cel.expr.conformance.proto2", + value: { + listValue: { + values: [ + { stringValue: "greetings" }, + { stringValue: "world" }, + ], + }, + }, + }, + error: + "ERROR: struct_list_optindex_field:1:45: unsupported syntax '?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ............................................^\nERROR: struct_list_optindex_field:1:83: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['greetings', ?{'nested': {'hello': 'world'}}.nested.?hello]}.repeated_string\n | ..................................................................................^", + }, + { + original: { + name: "optional_empty_map_optindex_hasValue", + expr: "optional.of({}).?c.hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: optional_empty_map_optindex_hasValue:1:16: unsupported syntax '.?'\n | optional.of({}).?c.hasValue()\n | ...............^", + }, + { + original: { + name: "empty_struct_optindex_hasValue", + expr: "TestAllTypes{}.?repeated_string.hasValue()", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + error: + "ERROR: empty_struct_optindex_hasValue:1:15: unsupported syntax '.?'\n | TestAllTypes{}.?repeated_string.hasValue()\n | ..............^", + }, + { + original: { + name: "optional_empty_struct_optindex_hasValue", + expr: "optional.of(TestAllTypes{}).?repeated_string.hasValue()", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + error: + "ERROR: optional_empty_struct_optindex_hasValue:1:28: unsupported syntax '.?'\n | optional.of(TestAllTypes{}).?repeated_string.hasValue()\n | ...........................^", + }, + { + original: { + name: "optional_none_optselect_hasValue", + expr: "optional.none().?repeated_string.hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: optional_none_optselect_hasValue:1:16: unsupported syntax '.?'\n | optional.none().?repeated_string.hasValue()\n | ...............^", + }, + { + original: { + name: "struct_optindex_value", + expr: "TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()", + container: "cel.expr.conformance.proto2", + value: { listValue: { values: [{ stringValue: "foo" }] } }, + }, + error: + "ERROR: struct_optindex_value:1:39: unsupported syntax '.?'\n | TestAllTypes{repeated_string: ['foo']}.?repeated_string.value()\n | ......................................^", + }, + { + original: { + name: "optional_struct_optindex_value", + expr: "optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()", + container: "cel.expr.conformance.proto2", + value: { listValue: { values: [{ stringValue: "foo" }] } }, + }, + error: + "ERROR: optional_struct_optindex_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()\n | ...................................................^", + }, + { + original: { + name: "optional_struct_optindex_index_value", + expr: "optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()", + container: "cel.expr.conformance.proto2", + value: { stringValue: "foo" }, + }, + error: + "ERROR: optional_struct_optindex_index_value:1:52: unsupported syntax '.?'\n | optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()\n | ...................................................^", + }, + { + original: { + name: "empty_list_optindex_hasValue", + expr: "[][?0].hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: empty_list_optindex_hasValue:1:3: unsupported syntax '[?'\n | [][?0].hasValue()\n | ..^", + }, + { + original: { + name: "optional_empty_list_optindex_hasValue", + expr: "optional.of([])[?0].hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: optional_empty_list_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.of([])[?0].hasValue()\n | ...............^", + }, + { + original: { + name: "optional_none_optindex_hasValue", + expr: "optional.none()[?0].hasValue()", + value: { boolValue: false }, + }, + error: + "ERROR: optional_none_optindex_hasValue:1:16: unsupported syntax '[?'\n | optional.none()[?0].hasValue()\n | ...............^", + }, + { + original: { + name: "list_optindex_value", + expr: "['foo'][?0].value()", + value: { stringValue: "foo" }, + }, + error: + "ERROR: list_optindex_value:1:8: unsupported syntax '[?'\n | ['foo'][?0].value()\n | .......^", + }, + { + original: { + name: "optional_list_optindex_value", + expr: "optional.of(['foo'])[?0].value()", + value: { stringValue: "foo" }, + }, + error: + "ERROR: optional_list_optindex_value:1:21: unsupported syntax '[?'\n | optional.of(['foo'])[?0].value()\n | ....................^", + }, + { + original: { + name: "map_key_mixed_type_optindex_value", + expr: "{true: 1, 2: 2, 5u: 3}[?true].value()", + value: { int64Value: "1" }, + }, + error: + "ERROR: map_key_mixed_type_optindex_value:1:23: unsupported syntax '[?'\n | {true: 1, 2: 2, 5u: 3}[?true].value()\n | ......................^", + }, + { + original: { + name: "map_key_mixed_numbers_double_key_optindex_value", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()", + value: { doubleValue: 3 }, + }, + error: + "ERROR: map_key_mixed_numbers_double_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0].value()\n | ..........................^", + }, + { + original: { + name: "map_key_mixed_numbers_uint_key_optindex_value", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()", + value: { doubleValue: 2 }, + }, + error: + "ERROR: map_key_mixed_numbers_uint_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?2u].value()\n | ..........................^", + }, + { + original: { + name: "map_key_mixed_numbers_int_key_optindex_value", + expr: "{1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()", + value: { doubleValue: 1 }, + }, + error: + "ERROR: map_key_mixed_numbers_int_key_optindex_value:1:27: unsupported syntax '[?'\n | {1u: 1.0, 2: 2.0, 3u: 3.0}[?1].value()\n | ..........................^", + }, + { + original: { + name: "optional_eq_none_none", + expr: "optional.none() == optional.none()", + value: { boolValue: true }, + }, + ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "optional_eq_none_int", + expr: "optional.none() == optional.of(1)", + value: { boolValue: false }, + }, + ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "optional_eq_int_none", + expr: "optional.of(1) == optional.none()", + value: { boolValue: false }, + }, + ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "optional_eq_int_int", + expr: "optional.of(1) == optional.of(1)", + value: { boolValue: true }, + }, + ast: "_==_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "optional_ne_none_none", + expr: "optional.none() != optional.none()", + value: { boolValue: false }, + }, + ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n optional.none()~optional_type(dyn)^optional_none,\n optional.none()~optional_type(dyn)^optional_none\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "optional_ne_none_int", + expr: "optional.none() != optional.of(1)", + value: { boolValue: true }, + }, + ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "optional_ne_int_none", + expr: "optional.of(1) != optional.none()", + value: { boolValue: true }, + }, + ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "optional_ne_int_int", + expr: "optional.of(1) != optional.of(1)", + value: { boolValue: false }, + }, + ast: "_!=_(\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_!=_(\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~bool^not_equals", + type: "bool", + }, + { + original: { + name: "map_optional_has", + expr: "has({'foo': optional.none()}.foo)", + value: { boolValue: true }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "foo"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~test-only~~bool', + type: "bool", + }, + { + original: { + name: "map_optional_select_has", + expr: "has({'foo': optional.none()}.foo.bar)", + value: { boolValue: false }, + }, + ast: '{\n "foo"^#*expr.Constant_StringValue#:optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.foo^#*expr.Expr_SelectExpr#.bar~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "foo"~string:optional.none()~optional_type(dyn)^optional_none\n}~map(string, optional_type(dyn)).foo~optional_type(dyn).bar~test-only~~bool', + type: "bool", + }, + { + original: { + name: "map_optional_entry_has", + expr: "has({?'foo': optional.none()}.foo)", + value: { boolValue: false }, + }, + error: + "ERROR: map_optional_entry_has:1:6: unsupported syntax '?'\n | has({?'foo': optional.none()}.foo)\n | .....^", + }, + ], + }, + ], + }, + { + name: "parse", + suites: [ + { + name: "nest", + tests: [ + { + original: { + name: "list_index", + description: + "Member = Member '[' Expr ']'. Nested indices are supported up to 12 times.", + expr: "a[a[a[a[a[a[a[a[a[a[a[a[0]]]]]]]]]]]]", + typeEnv: [ + { + name: "a", + ident: { + type: { listType: { elemType: { primitive: "INT64" } } }, + }, + }, + ], + bindings: { + a: { + value: { listValue: { values: [{ int64Value: "0" }] } }, + }, + }, + value: { int64Value: "0" }, + }, + ast: "_[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n _[_](\n a^#*expr.Expr_IdentExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n _[_](\n a~list(int)^a,\n 0~int\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n )~int^index_list\n)~int^index_list", + type: "int", + }, + { + original: { + name: "message_literal", + description: + "Member = Member '{' [FieldInits] '}'. Nested messages supported up to 12 levels deep.", + expr: "NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{child: NestedTestAllTypes{payload: TestAllTypes{single_int64: 137}}}}}}}}}}}}.payload.single_int64", + container: "cel.expr.conformance.proto3", + value: { int64Value: "0" }, + }, + ast: "NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n child:NestedTestAllTypes{\n payload:TestAllTypes{\n single_int64:137^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.payload^#*expr.Expr_SelectExpr#.single_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n child:cel.expr.conformance.proto3.NestedTestAllTypes{\n payload:cel.expr.conformance.proto3.TestAllTypes{\n single_int64:137~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n }~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes\n}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int64~int", + type: "int", + }, + { + original: { + name: "funcall", + description: + "Primary = ['.'] IDENT ['(' [ExprList] ')']. Nested function calls supported up to 12 levels deep.", + expr: "int(uint(int(uint(int(uint(int(uint(int(uint(int(uint(7))))))))))))", + value: { int64Value: "7" }, + }, + ast: "int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n int(\n uint(\n 7~int\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n )~int^uint64_to_int64\n )~uint^int64_to_uint64\n)~int^uint64_to_int64", + type: "int", + }, + { + original: { + name: "list_literal", + description: + "Primary = '[' [ExprList] ']'. Nested list literals up to 12 levels deep.", + expr: "size([[[[[[[[[[[[0]]]]]]]]]]]])", + value: { int64Value: "1" }, + }, + ast: "size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "size(\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n 0~int\n ]~list(int)\n ]~list(list(int))\n ]~list(list(list(int)))\n ]~list(list(list(list(int))))\n ]~list(list(list(list(list(int)))))\n ]~list(list(list(list(list(list(int))))))\n ]~list(list(list(list(list(list(list(int)))))))\n ]~list(list(list(list(list(list(list(list(int))))))))\n ]~list(list(list(list(list(list(list(list(list(int)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(int))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(int)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(int))))))))))))\n)~int^size_list", + type: "int", + }, + { + original: { + name: "map_literal", + description: + "Primary = '{' [MapInits] '}'. Nested map literals up to 12 levels deep.", + expr: "size({0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: 'foo'}}}}}}}}}}}})", + value: { int64Value: "1" }, + }, + ast: 'size(\n {\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:{\n 0^#*expr.Constant_Int64Value#:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'size(\n {\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:{\n 0~int:"foo"~string\n }~map(int, string)\n }~map(int, map(int, string))\n }~map(int, map(int, map(int, string)))\n }~map(int, map(int, map(int, map(int, string))))\n }~map(int, map(int, map(int, map(int, map(int, string)))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, string))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string)))))))))))\n }~map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, map(int, string))))))))))))\n)~int^size_map', + type: "int", + }, + { + original: { + name: "parens", + description: "Primary = '(' Expr ')'", + expr: "((((((((((((((((((((((((((((((((7))))))))))))))))))))))))))))))))", + value: { int64Value: "7" }, + }, + error: + "ERROR: parens:-1:0: expression recursion limit exceeded: 32", + }, + ], + }, + { + name: "repeat", + tests: [ + { + original: { + name: "conditional", + description: + "Expr = ConditionalOr ['?' ConditionalOr ':' Expr]. Chained ternary operators up to 24 levels.", + expr: "true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : true ? true : false", + value: { boolValue: true }, + }, + ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n _?_:_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n _?_:_(\n true~bool,\n true~bool,\n false~bool\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n )~bool^conditional\n)~bool^conditional", + type: "bool", + }, + { + original: { + name: "or", + description: + "ConditionalOr = [ConditionalOr '||'] ConditionalAnd. Logical OR statements with 32 conditions.", + expr: "false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || false || true", + value: { boolValue: true }, + }, + ast: "_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _||_(\n _||_(\n false^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _||_(\n false^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_||_(\n _||_(\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or\n )~bool^logical_or,\n _||_(\n _||_(\n false~bool,\n false~bool\n )~bool^logical_or,\n _||_(\n false~bool,\n true~bool\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n )~bool^logical_or\n)~bool^logical_or", + type: "bool", + }, + { + original: { + name: "and", + description: + "ConditionalAnd = [ConditionalAnd '\u0026\u0026'] Relation. Logical AND statements with 32 conditions.", + expr: "true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 true \u0026\u0026 false", + value: { boolValue: false }, + }, + ast: "_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n _\u0026\u0026_(\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and\n )~bool^logical_and,\n _\u0026\u0026_(\n _\u0026\u0026_(\n true~bool,\n true~bool\n )~bool^logical_and,\n _\u0026\u0026_(\n true~bool,\n false~bool\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n )~bool^logical_and\n)~bool^logical_and", + type: "bool", + }, + { + original: { + name: "add_sub", + description: + "Addition = [Addition ('+' | '-')] Multiplication. Addition operators are supported up to 24 times consecutively.", + expr: "3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3 - 3 + 3", + value: { int64Value: "3" }, + }, + ast: "_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n _+_(\n _-_(\n 3~int,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n )~int^add_int64,\n 3~int\n )~int^subtract_int64,\n 3~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "mul_div", + description: + "Multiplication = [Multiplication ('*' | '/' | '%')] Unary. Multiplication operators are supported up to 24 times consecutively.", + expr: "4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4 * 4 / 4", + value: { int64Value: "4" }, + }, + ast: "_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n _/_(\n _*_(\n 4~int,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n )~int^divide_int64,\n 4~int\n )~int^multiply_int64,\n 4~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "not", + description: "Unary = '!' {'!'} Member", + expr: "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!true", + value: { boolValue: true }, + }, + ast: "true^#*expr.Constant_BoolValue#", + checkedAst: "true~bool", + type: "bool", + }, + { + original: { + name: "unary_neg", + description: "Unary = '-' {'-'} Member", + expr: "--------------------------------19", + value: { int64Value: "19" }, + }, + ast: "19^#*expr.Constant_Int64Value#", + checkedAst: "19~int", + type: "int", + }, + { + original: { + name: "select", + description: + "Member = Member '.' IDENT ['(' [ExprList] ')']. Selection is supported up to 12 times consecutively.", + expr: "NestedTestAllTypes{}.child.child.child.child.child.child.child.child.child.child.payload.single_int32", + container: "cel.expr.conformance.proto3", + value: { int64Value: "0" }, + }, + ast: "NestedTestAllTypes{}^#*expr.Expr_StructExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.child^#*expr.Expr_SelectExpr#.payload^#*expr.Expr_SelectExpr#.single_int32^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.NestedTestAllTypes{}~cel.expr.conformance.proto3.NestedTestAllTypes^cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.child~cel.expr.conformance.proto3.NestedTestAllTypes.payload~cel.expr.conformance.proto3.TestAllTypes.single_int32~int", + type: "int", + }, + { + original: { + name: "index", + description: + "Member = Member '[' Expr ']'. Indexing is supported up to 12 times consecutively.", + expr: "[[[[[[[[[[[['foo']]]]]]]]]]]][0][0][0][0][0][0][0][0][0][0][0][0]", + value: { stringValue: "foo" }, + }, + ast: '_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n "foo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n _[_](\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n [\n "foo"~string\n ]~list(string)\n ]~list(list(string))\n ]~list(list(list(string)))\n ]~list(list(list(list(string))))\n ]~list(list(list(list(list(string)))))\n ]~list(list(list(list(list(list(string))))))\n ]~list(list(list(list(list(list(list(string)))))))\n ]~list(list(list(list(list(list(list(list(string))))))))\n ]~list(list(list(list(list(list(list(list(list(string)))))))))\n ]~list(list(list(list(list(list(list(list(list(list(string))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))\n ]~list(list(list(list(list(list(list(list(list(list(list(list(string)))))))))))),\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(list(string)))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(list(string))))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(list(string)))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(list(string))))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(list(string)))))))^index_list,\n 0~int\n )~list(list(list(list(list(list(string))))))^index_list,\n 0~int\n )~list(list(list(list(list(string)))))^index_list,\n 0~int\n )~list(list(list(list(string))))^index_list,\n 0~int\n )~list(list(list(string)))^index_list,\n 0~int\n )~list(list(string))^index_list,\n 0~int\n )~list(string)^index_list,\n 0~int\n)~string^index_list', + type: "string", + }, + { + original: { + name: "list_literal", + description: + "Primary = '[' [ExprList] ']'. List literals with up to 32 elements.", + expr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31][17]", + value: { int64Value: "17" }, + }, + ast: "_[_](\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 9^#*expr.Constant_Int64Value#,\n 10^#*expr.Constant_Int64Value#,\n 11^#*expr.Constant_Int64Value#,\n 12^#*expr.Constant_Int64Value#,\n 13^#*expr.Constant_Int64Value#,\n 14^#*expr.Constant_Int64Value#,\n 15^#*expr.Constant_Int64Value#,\n 16^#*expr.Constant_Int64Value#,\n 17^#*expr.Constant_Int64Value#,\n 18^#*expr.Constant_Int64Value#,\n 19^#*expr.Constant_Int64Value#,\n 20^#*expr.Constant_Int64Value#,\n 21^#*expr.Constant_Int64Value#,\n 22^#*expr.Constant_Int64Value#,\n 23^#*expr.Constant_Int64Value#,\n 24^#*expr.Constant_Int64Value#,\n 25^#*expr.Constant_Int64Value#,\n 26^#*expr.Constant_Int64Value#,\n 27^#*expr.Constant_Int64Value#,\n 28^#*expr.Constant_Int64Value#,\n 29^#*expr.Constant_Int64Value#,\n 30^#*expr.Constant_Int64Value#,\n 31^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n 0~int,\n 1~int,\n 2~int,\n 3~int,\n 4~int,\n 5~int,\n 6~int,\n 7~int,\n 8~int,\n 9~int,\n 10~int,\n 11~int,\n 12~int,\n 13~int,\n 14~int,\n 15~int,\n 16~int,\n 17~int,\n 18~int,\n 19~int,\n 20~int,\n 21~int,\n 22~int,\n 23~int,\n 24~int,\n 25~int,\n 26~int,\n 27~int,\n 28~int,\n 29~int,\n 30~int,\n 31~int\n ]~list(int),\n 17~int\n)~int^index_list", + type: "int", + }, + { + original: { + name: "map_literal", + description: + "Primary = '{' [MapInits] '}'. Map literals with up to 32 entries.", + expr: "{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine', 10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen', 14: 'fourteen', 15: 'fifteen', 16: 'sixteen', 17: 'seventeen', 18: 'eighteen', 19: 'nineteen', 20: 'twenty', 21: 'twenty-one', 22: 'twenty-two', 23: 'twenty-three', 24: 'twenty-four', 25: 'twenty-five', 26: 'twenty-six', 27: 'twenty-seven', 28: 'twenty-eight', 29: 'twenty-nine', 30: 'thirty', 31: 'thirty-one'}[17]", + value: { stringValue: "seventeen" }, + }, + ast: '_[_](\n {\n 0^#*expr.Constant_Int64Value#:"zero"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 1^#*expr.Constant_Int64Value#:"one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:"two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 3^#*expr.Constant_Int64Value#:"three"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 4^#*expr.Constant_Int64Value#:"four"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 5^#*expr.Constant_Int64Value#:"five"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:"six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 7^#*expr.Constant_Int64Value#:"seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 8^#*expr.Constant_Int64Value#:"eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 9^#*expr.Constant_Int64Value#:"nine"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 10^#*expr.Constant_Int64Value#:"ten"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 11^#*expr.Constant_Int64Value#:"eleven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 12^#*expr.Constant_Int64Value#:"twelve"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 13^#*expr.Constant_Int64Value#:"thirteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 14^#*expr.Constant_Int64Value#:"fourteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 15^#*expr.Constant_Int64Value#:"fifteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 16^#*expr.Constant_Int64Value#:"sixteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 17^#*expr.Constant_Int64Value#:"seventeen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 18^#*expr.Constant_Int64Value#:"eighteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 19^#*expr.Constant_Int64Value#:"nineteen"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 20^#*expr.Constant_Int64Value#:"twenty"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 21^#*expr.Constant_Int64Value#:"twenty-one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 22^#*expr.Constant_Int64Value#:"twenty-two"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 23^#*expr.Constant_Int64Value#:"twenty-three"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 24^#*expr.Constant_Int64Value#:"twenty-four"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 25^#*expr.Constant_Int64Value#:"twenty-five"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 26^#*expr.Constant_Int64Value#:"twenty-six"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 27^#*expr.Constant_Int64Value#:"twenty-seven"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 28^#*expr.Constant_Int64Value#:"twenty-eight"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 29^#*expr.Constant_Int64Value#:"twenty-nine"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 30^#*expr.Constant_Int64Value#:"thirty"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 31^#*expr.Constant_Int64Value#:"thirty-one"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n 17^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n 0~int:"zero"~string,\n 1~int:"one"~string,\n 2~int:"two"~string,\n 3~int:"three"~string,\n 4~int:"four"~string,\n 5~int:"five"~string,\n 6~int:"six"~string,\n 7~int:"seven"~string,\n 8~int:"eight"~string,\n 9~int:"nine"~string,\n 10~int:"ten"~string,\n 11~int:"eleven"~string,\n 12~int:"twelve"~string,\n 13~int:"thirteen"~string,\n 14~int:"fourteen"~string,\n 15~int:"fifteen"~string,\n 16~int:"sixteen"~string,\n 17~int:"seventeen"~string,\n 18~int:"eighteen"~string,\n 19~int:"nineteen"~string,\n 20~int:"twenty"~string,\n 21~int:"twenty-one"~string,\n 22~int:"twenty-two"~string,\n 23~int:"twenty-three"~string,\n 24~int:"twenty-four"~string,\n 25~int:"twenty-five"~string,\n 26~int:"twenty-six"~string,\n 27~int:"twenty-seven"~string,\n 28~int:"twenty-eight"~string,\n 29~int:"twenty-nine"~string,\n 30~int:"thirty"~string,\n 31~int:"thirty-one"~string\n }~map(int, string),\n 17~int\n)~string^index_map', + type: "string", + }, + { + original: { + name: "message_literal", + description: + "Member = Member '{' [FieldInits] '}'. Message literals with up to 32 fields.", + expr: "TestAllTypes{single_int32: 5, single_int64: 10, single_uint32: 15u, single_uint64: 20u, single_sint32: 25, single_sint64: 30, single_fixed32: 35u, single_fixed64: 40u, single_float: 45.0, single_double: 50.0, single_bool: true, single_string: 'sixty', single_bytes: b'sixty-five', single_value: 70.0, single_int64_wrapper: 75, single_int32_wrapper: 80, single_double_wrapper: 85.0, single_float_wrapper: 90.0, single_uint64_wrapper: 95u, single_uint32_wrapper: 100u, single_string_wrapper: 'one hundred five', single_bool_wrapper: true, repeated_int32: [115], repeated_int64: [120], repeated_uint32: [125u], repeated_uint64: [130u], repeated_sint32: [135], repeated_sint64: [140], repeated_fixed32: [145u], repeated_fixed64: [150u], repeated_sfixed32: [155], repeated_float: [160.0]}.single_sint64", + container: "cel.expr.conformance.proto3", + value: { int64Value: "30" }, + }, + ast: 'TestAllTypes{\n single_int32:5^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int64:10^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32:15u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64:20u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint32:25^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_sint64:30^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed32:35u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_fixed64:40u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_float:45^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_double:50^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n single_string:"sixty"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bytes:b"sixty-five"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n single_value:70^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_int64_wrapper:75^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_int32_wrapper:80^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_double_wrapper:85^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_float_wrapper:90^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#,\n single_uint64_wrapper:95u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_uint32_wrapper:100u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#,\n single_string_wrapper:"one hundred five"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int32:[\n 115^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_int64:[\n 120^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint32:[\n 125u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_uint64:[\n 130u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint32:[\n 135^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sint64:[\n 140^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed32:[\n 145u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_fixed64:[\n 150u^#*expr.Constant_Uint64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_sfixed32:[\n 155^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#,\n repeated_float:[\n 160^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint64^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_int32:5~int,\n single_int64:10~int,\n single_uint32:15u~uint,\n single_uint64:20u~uint,\n single_sint32:25~int,\n single_sint64:30~int,\n single_fixed32:35u~uint,\n single_fixed64:40u~uint,\n single_float:45~double,\n single_double:50~double,\n single_bool:true~bool,\n single_string:"sixty"~string,\n single_bytes:b"sixty-five"~bytes,\n single_value:70~double,\n single_int64_wrapper:75~int,\n single_int32_wrapper:80~int,\n single_double_wrapper:85~double,\n single_float_wrapper:90~double,\n single_uint64_wrapper:95u~uint,\n single_uint32_wrapper:100u~uint,\n single_string_wrapper:"one hundred five"~string,\n single_bool_wrapper:true~bool,\n repeated_int32:[\n 115~int\n ]~list(int),\n repeated_int64:[\n 120~int\n ]~list(int),\n repeated_uint32:[\n 125u~uint\n ]~list(uint),\n repeated_uint64:[\n 130u~uint\n ]~list(uint),\n repeated_sint32:[\n 135~int\n ]~list(int),\n repeated_sint64:[\n 140~int\n ]~list(int),\n repeated_fixed32:[\n 145u~uint\n ]~list(uint),\n repeated_fixed64:[\n 150u~uint\n ]~list(uint),\n repeated_sfixed32:[\n 155~int\n ]~list(int),\n repeated_float:[\n 160~double\n ]~list(double)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_sint64~int', + type: "int", + }, + ], + }, + { + name: "string_literals", + tests: [ + { + original: { + name: "single_quoted", + expr: "'hello'", + value: { stringValue: "hello" }, + }, + ast: '"hello"^#*expr.Constant_StringValue#', + checkedAst: '"hello"~string', + type: "string", + }, + { + original: { + name: "double_quoted", + expr: '"hello"', + value: { stringValue: "hello" }, + }, + ast: '"hello"^#*expr.Constant_StringValue#', + checkedAst: '"hello"~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted", + expr: "'''hello'''", + value: { stringValue: "hello" }, + }, + ast: '"hello"^#*expr.Constant_StringValue#', + checkedAst: '"hello"~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted", + expr: '"""hello"""', + value: { stringValue: "hello" }, + }, + ast: '"hello"^#*expr.Constant_StringValue#', + checkedAst: '"hello"~string', + type: "string", + }, + { + original: { + name: "single_quoted_escaped_punctuation", + expr: "' \\\\ \\? \\\" \\' \\` '", + value: { stringValue: " \\ ? \" ' ` " }, + }, + ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', + checkedAst: '" \\\\ ? \\" \' ` "~string', + type: "string", + }, + { + original: { + name: "double_quoted_escaped_punctuation", + expr: '" \\\\ \\? \\" \\\' \\` "', + value: { stringValue: " \\ ? \" ' ` " }, + }, + ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', + checkedAst: '" \\\\ ? \\" \' ` "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_escaped_punctuation", + expr: "''' \\\\ \\? \\\" \\' \\` '''", + value: { stringValue: " \\ ? \" ' ` " }, + }, + ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', + checkedAst: '" \\\\ ? \\" \' ` "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_escaped_punctuation", + expr: '""" \\\\ \\? \\" \\\' \\` """', + value: { stringValue: " \\ ? \" ' ` " }, + }, + ast: '" \\\\ ? \\" \' ` "^#*expr.Constant_StringValue#', + checkedAst: '" \\\\ ? \\" \' ` "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_unescaped_punctuation", + expr: "''' ? \" ' ` '''", + value: { stringValue: " ? \" ' ` " }, + }, + ast: '" ? \\" \' ` "^#*expr.Constant_StringValue#', + checkedAst: '" ? \\" \' ` "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_unescaped_punctuation", + expr: '""" ? " \' ` """', + value: { stringValue: " ? \" ' ` " }, + }, + ast: '" ? \\" \' ` "^#*expr.Constant_StringValue#', + checkedAst: '" ? \\" \' ` "~string', + type: "string", + }, + { + original: { + name: "single_quoted_escaped_special_control_characters", + expr: "' \\a \\b \\f \\t \\v '", + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "double_quoted_escaped_special_control_characters", + expr: '" \\a \\b \\f \\t \\v "', + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "single_quoted_unescaped_special_control_characters", + expr: "' \u0007 \b \f \t \u000b '", + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "double_quoted_unescaped_special_control_characters", + expr: '" \u0007 \b \f \t \u000b "', + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_escaped_special_control_characters", + expr: "''' \\a \\b \\f \\t \\v '''", + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_escaped_special_control_characters", + expr: '""" \\a \\b \\f \\t \\v """', + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_unescaped_special_control_characters", + expr: "''' \u0007 \b \f \t \u000b '''", + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_unescaped_special_control_characters", + expr: '""" \u0007 \b \f \t \u000b """', + value: { stringValue: " \u0007 \b \f \t \u000b " }, + }, + ast: '" \\a \\b \\f \\t \\v "^#*expr.Constant_StringValue#', + checkedAst: '" \\a \\b \\f \\t \\v "~string', + type: "string", + }, + { + original: { + name: "single_quoted_escaped_line_feed", + expr: "' \\n '", + value: { stringValue: " \n " }, + }, + ast: '" \\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\n "~string', + type: "string", + }, + { + original: { + name: "double_quoted_escaped_line_feed", + expr: '" \\n "', + value: { stringValue: " \n " }, + }, + ast: '" \\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\n "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_escaped_line_feed", + expr: "''' \\n '''", + value: { stringValue: " \n " }, + }, + ast: '" \\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\n "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_escaped_line_feed", + expr: '""" \\n """', + value: { stringValue: " \n " }, + }, + ast: '" \\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\n "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_unescaped_line_feed", + expr: "''' \n '''", + value: { stringValue: " \n " }, + }, + ast: '" \\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\n "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_unescaped_line_feed", + expr: '""" \n """', + value: { stringValue: " \n " }, + }, + ast: '" \\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\n "~string', + type: "string", + }, + { + original: { + name: "single_quoted_escaped_carriage_return", + expr: "' \\r '", + value: { stringValue: " \r " }, + }, + ast: '" \\r "^#*expr.Constant_StringValue#', + checkedAst: '" \\r "~string', + type: "string", + }, + { + original: { + name: "double_quoted_escaped_carriage_return", + expr: '" \\r "', + value: { stringValue: " \r " }, + }, + ast: '" \\r "^#*expr.Constant_StringValue#', + checkedAst: '" \\r "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_escaped_carriage_return", + expr: "''' \\r '''", + value: { stringValue: " \r " }, + }, + ast: '" \\r "^#*expr.Constant_StringValue#', + checkedAst: '" \\r "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_escaped_carriage_return", + expr: '""" \\r """', + value: { stringValue: " \r " }, + }, + ast: '" \\r "^#*expr.Constant_StringValue#', + checkedAst: '" \\r "~string', + type: "string", + }, + { + original: { + name: "single_quoted_escaped_windows_line_end", + expr: "' \\r\\n '", + value: { stringValue: " \r\n " }, + }, + ast: '" \\r\\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\r\\n "~string', + type: "string", + }, + { + original: { + name: "double_quoted_escaped_windows_line_end", + expr: '" \\r\\n "', + value: { stringValue: " \r\n " }, + }, + ast: '" \\r\\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\r\\n "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_escaped_windows_line_end", + expr: "''' \\r\\n '''", + value: { stringValue: " \r\n " }, + }, + ast: '" \\r\\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\r\\n "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_escaped_windows_line_end", + expr: '""" \\r\\n """', + value: { stringValue: " \r\n " }, + }, + ast: '" \\r\\n "^#*expr.Constant_StringValue#', + checkedAst: '" \\r\\n "~string', + type: "string", + }, + { + original: { + name: "single_quoted_escaped_all_control_characters", + expr: "' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '", + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "double_quoted_escaped_all_control_characters", + expr: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F "', + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "single_quoted_unescaped_all_control_characters", + expr: "' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '", + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "double_quoted_unescaped_all_control_characters", + expr: '" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "', + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_escaped_all_control_characters", + expr: "''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''", + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_escaped_all_control_characters", + expr: '""" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F """', + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_unescaped_all_control_characters", + expr: "''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''", + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_unescaped_all_control_characters", + expr: '""" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  """', + value: { + stringValue: + " \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  ", + }, + }, + ast: '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_StringValue#', + checkedAst: + '" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~string', + type: "string", + }, + { + original: { + name: "single_quoted_octal_escapes", + expr: "' \\000 \\012 \\177 '", + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "double_quoted_octal_escapes", + expr: '" \\000 \\012 \\177 "', + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_octal_escapes", + expr: "''' \\000 \\012 \\177 '''", + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_octal_escapes", + expr: '""" \\000 \\012 \\177 """', + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "single_quoted_lower_x_escapes", + expr: "' \\x00 \\x0A \\x7F '", + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "double_quoted_lower_x_escapes", + expr: '" \\x00 \\x0A \\x7F "', + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_lower_x_escapes", + expr: "''' \\x00 \\x0A \\x7F '''", + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_lower_x_escapes", + expr: '""" \\x00 \\x0A \\x7F """', + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "single_quoted_upper_x_escapes", + expr: "' \\X00 \\X0A \\X7F '", + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "double_quoted_upper_x_escapes", + expr: '" \\X00 \\X0A \\X7F "', + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_upper_x_escapes", + expr: "''' \\X00 \\X0A \\X7F '''", + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_upper_x_escapes", + expr: '""" \\X00 \\X0A \\X7F """', + value: { stringValue: " \u0000 \n  " }, + }, + ast: '" \\x00 \\n \\x7f "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f "~string', + type: "string", + }, + { + original: { + name: "single_quoted_lower_u_escapes", + expr: "' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '", + value: { stringValue: " \u0000 \n  Ā  " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', + type: "string", + }, + { + original: { + name: "double_quoted_lower_u_escapes", + expr: '" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB "', + value: { stringValue: " \u0000 \n  Ā  " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_lower_u_escapes", + expr: "''' \\u0000 \\u000A \\u007F \\u0100 \\uFFFB '''", + value: { stringValue: " \u0000 \n  Ā  " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_lower_u_escapes", + expr: '""" \\u0000 \\u000A \\u007F \\u0100 \\uFFFB """', + value: { stringValue: " \u0000 \n  Ā  " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb "~string', + type: "string", + }, + { + original: { + name: "single_quoted_upper_u_escapes", + expr: "' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '", + value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', + type: "string", + }, + { + original: { + name: "double_quoted_upper_u_escapes", + expr: '" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C "', + value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', + type: "string", + }, + { + original: { + name: "triple_single_quoted_upper_u_escapes", + expr: "''' \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C '''", + value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', + type: "string", + }, + { + original: { + name: "triple_double_quoted_upper_u_escapes", + expr: '""" \\U00000000 \\U0000000A \\U0000007F \\U00000100 \\U0000FFFB \\U00010000 \\U0001F62C """', + value: { stringValue: " \u0000 \n  Ā  𐀀 😬 " }, + }, + ast: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "^#*expr.Constant_StringValue#', + checkedAst: '" \\x00 \\n \\x7f Ā \\ufffb 𐀀 😬 "~string', + type: "string", + }, + { + original: { + name: "mixed_case_hex_single_quoted_escapes", + expr: "' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '", + value: { stringValue: " J K L M ƫ ƫ " }, + }, + ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', + checkedAst: '" J K L M ƫ ƫ "~string', + type: "string", + }, + { + original: { + name: "mixed_case_hex_double_quoted_escapes", + expr: '" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB "', + value: { stringValue: " J K L M ƫ ƫ " }, + }, + ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', + checkedAst: '" J K L M ƫ ƫ "~string', + type: "string", + }, + { + original: { + name: "mixed_case_hex_triple_single_quoted_escapes", + expr: "''' \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB '''", + value: { stringValue: " J K L M ƫ ƫ " }, + }, + ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', + checkedAst: '" J K L M ƫ ƫ "~string', + type: "string", + }, + { + original: { + name: "mixed_case_hex_triple_double_quoted_escapes", + expr: '""" \\x4a \\x4B \\X4c \\X4D \\u01aB \\U000001aB """', + value: { stringValue: " J K L M ƫ ƫ " }, + }, + ast: '" J K L M ƫ ƫ "^#*expr.Constant_StringValue#', + checkedAst: '" J K L M ƫ ƫ "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_single_quoted_escapes", + expr: "' \\U00088888 '", + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_double_quoted_escapes", + expr: '" \\U00088888 "', + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_triple_single_quoted_escapes", + expr: "''' \\U00088888 '''", + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_triple_double_quoted_escapes", + expr: '""" \\U00088888 """', + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_single_quoted_unescaped", + expr: "' 򈢈 '", + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_double_quoted_unescaped", + expr: '" 򈢈 "', + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_triple_single_quoted_unescaped", + expr: "''' 򈢈 '''", + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "unassigned_code_point_triple_double_quoted_unescaped", + expr: '""" 򈢈 """', + value: { stringValue: " 򈢈 " }, + }, + ast: '" \\U00088888 "^#*expr.Constant_StringValue#', + checkedAst: '" \\U00088888 "~string', + type: "string", + }, + { + original: { + name: "raw_single_quoted_escapes", + expr: "r' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", + value: { + stringValue: + ' \\\\ \\? \\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ', + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "raw_double_quoted_escapes", + expr: 'r" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', + value: { + stringValue: + " \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "raw_triple_single_quoted_escapes", + expr: "r''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", + value: { + stringValue: + " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "raw_triple_double_quoted_escapes", + expr: 'r""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', + value: { + stringValue: + " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "upper_raw_single_quoted_escapes", + expr: "R' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", + value: { + stringValue: + ' \\\\ \\? \\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ', + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "upper_raw_double_quoted_escapes", + expr: 'R" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', + value: { + stringValue: + " \\\\ \\? \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "upper_raw_triple_single_quoted_escapes", + expr: "R''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", + value: { + stringValue: + " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + { + original: { + name: "upper_raw_triple_double_quoted_escapes", + expr: 'R""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', + value: { + stringValue: + " \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 ", + }, + }, + ast: '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_StringValue#', + checkedAst: + '" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~string', + type: "string", + }, + ], + }, + { + name: "bytes_literals", + tests: [ + { + original: { + name: "single_quoted", + expr: "b'hello'", + value: { bytesValue: "aGVsbG8=" }, + }, + ast: 'b"hello"^#*expr.Constant_BytesValue#', + checkedAst: 'b"hello"~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted", + expr: 'b"hello"', + value: { bytesValue: "aGVsbG8=" }, + }, + ast: 'b"hello"^#*expr.Constant_BytesValue#', + checkedAst: 'b"hello"~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted", + expr: "b'''hello'''", + value: { bytesValue: "aGVsbG8=" }, + }, + ast: 'b"hello"^#*expr.Constant_BytesValue#', + checkedAst: 'b"hello"~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted", + expr: 'b"""hello"""', + value: { bytesValue: "aGVsbG8=" }, + }, + ast: 'b"hello"^#*expr.Constant_BytesValue#', + checkedAst: 'b"hello"~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_escaped_punctuation", + expr: "b' \\\\ \\? \\\" \\' \\` '", + value: { bytesValue: "IFwgPyAiICcgYCA=" }, + }, + ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_escaped_punctuation", + expr: 'b" \\\\ \\? \\" \\\' \\` "', + value: { bytesValue: "IFwgPyAiICcgYCA=" }, + }, + ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_escaped_punctuation", + expr: "b''' \\\\ \\? \\\" \\' \\` '''", + value: { bytesValue: "IFwgPyAiICcgYCA=" }, + }, + ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_escaped_punctuation", + expr: 'b""" \\\\ \\? \\" \\\' \\` """', + value: { bytesValue: "IFwgPyAiICcgYCA=" }, + }, + ast: 'b" \\\\ ? \\" \' ` "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\\\ ? \\" \' ` "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_unescaped_punctuation", + expr: "b''' ? \" ' ` '''", + value: { bytesValue: "ID8gIiAnIGAg" }, + }, + ast: 'b" ? \\" \' ` "^#*expr.Constant_BytesValue#', + checkedAst: 'b" ? \\" \' ` "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_unescaped_punctuation", + expr: 'b""" ? " \' ` """', + value: { bytesValue: "ID8gIiAnIGAg" }, + }, + ast: 'b" ? \\" \' ` "^#*expr.Constant_BytesValue#', + checkedAst: 'b" ? \\" \' ` "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_escaped_special_control_characters", + expr: "b' \\a \\b \\f \\t \\v '", + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_escaped_special_control_characters", + expr: 'b" \\a \\b \\f \\t \\v "', + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_unescaped_special_control_characters", + expr: "b' \u0007 \b \f \t \u000b '", + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_unescaped_special_control_characters", + expr: 'b" \u0007 \b \f \t \u000b "', + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_escaped_special_control_characters", + expr: "b''' \\a \\b \\f \\t \\v '''", + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_escaped_special_control_characters", + expr: 'b""" \\a \\b \\f \\t \\v """', + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_unescaped_special_control_characters", + expr: "b''' \u0007 \b \f \t \u000b '''", + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_unescaped_special_control_characters", + expr: 'b""" \u0007 \b \f \t \u000b """', + value: { bytesValue: "IAcgCCAMIAkgCyA=" }, + }, + ast: 'b" \\a \\b \\f \\t \\v "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\a \\b \\f \\t \\v "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_escaped_line_feed", + expr: "b' \\n '", + value: { bytesValue: "IAog" }, + }, + ast: 'b" \\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\n "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_escaped_line_feed", + expr: 'b" \\n "', + value: { bytesValue: "IAog" }, + }, + ast: 'b" \\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\n "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_escaped_line_feed", + expr: "b''' \\n '''", + value: { bytesValue: "IAog" }, + }, + ast: 'b" \\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\n "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_escaped_line_feed", + expr: 'b""" \\n """', + value: { bytesValue: "IAog" }, + }, + ast: 'b" \\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\n "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_unescaped_line_feed", + expr: "b''' \n '''", + value: { bytesValue: "IAog" }, + }, + ast: 'b" \\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\n "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_unescaped_line_feed", + expr: 'b""" \n """', + value: { bytesValue: "IAog" }, + }, + ast: 'b" \\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\n "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_escaped_carriage_return", + expr: "b' \\r '", + value: { bytesValue: "IA0g" }, + }, + ast: 'b" \\r "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_escaped_carriage_return", + expr: 'b" \\r "', + value: { bytesValue: "IA0g" }, + }, + ast: 'b" \\r "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_escaped_carriage_return", + expr: "b''' \\r '''", + value: { bytesValue: "IA0g" }, + }, + ast: 'b" \\r "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_escaped_carriage_return", + expr: 'b""" \\r """', + value: { bytesValue: "IA0g" }, + }, + ast: 'b" \\r "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_escaped_windows_line_end", + expr: "b' \\r\\n '", + value: { bytesValue: "IA0KIA==" }, + }, + ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r\\n "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_escaped_windows_line_end", + expr: 'b" \\r\\n "', + value: { bytesValue: "IA0KIA==" }, + }, + ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r\\n "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_escaped_windows_line_end", + expr: "b''' \\r\\n '''", + value: { bytesValue: "IA0KIA==" }, + }, + ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r\\n "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_escaped_windows_line_end", + expr: 'b""" \\r\\n """', + value: { bytesValue: "IA0KIA==" }, + }, + ast: 'b" \\r\\n "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\r\\n "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_escaped_all_control_characters", + expr: "b' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '", + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_escaped_all_control_characters", + expr: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F "', + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_unescaped_all_control_characters", + expr: "b' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '", + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_unescaped_all_control_characters", + expr: 'b" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  "', + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_escaped_all_control_characters", + expr: "b''' \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F '''", + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_escaped_all_control_characters", + expr: 'b""" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\x07 \\x08 \\x09 \\x0B \\x0C \\x0E \\x0F \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1A \\x1B \\x1C \\x1D \\x1E \\x1f \\x7F """', + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_unescaped_all_control_characters", + expr: "b''' \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  '''", + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_unescaped_all_control_characters", + expr: 'b""" \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t \u000b \f \u000e \u000f \u0010 \u0011 \u0012 \u0013 \u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b \u001c \u001d \u001e \u001f  """', + value: { + bytesValue: + "IAEgAiADIAQgBSAGIAcgCCAJIAsgDCAOIA8gECARIBIgEyAUIBUgFiAXIBggGSAaIBsgHCAdIB4gHyB/IA==", + }, + }, + ast: 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\x01 \\x02 \\x03 \\x04 \\x05 \\x06 \\a \\b \\t \\v \\f \\x0e \\x0f \\x10 \\x11 \\x12 \\x13 \\x14 \\x15 \\x16 \\x17 \\x18 \\x19 \\x1a \\x1b \\x1c \\x1d \\x1e \\x1f \\x7f "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_octal_escapes", + expr: "b' \\000 \\012 \\177 \\377 '", + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_octal_escapes", + expr: 'b" \\000 \\012 \\177 \\377 "', + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_octal_escapes", + expr: "b''' \\000 \\012 \\177 \\377 '''", + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_octal_escapes", + expr: 'b""" \\000 \\012 \\177 \\377 """', + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_lower_x_escapes", + expr: "b' \\x00 \\x0A \\x7F \\xFF '", + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_lower_x_escapes", + expr: 'b" \\x00 \\x0A \\x7F \\xFF "', + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_lower_x_escapes", + expr: "b''' \\x00 \\x0A \\x7F \\xFF '''", + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_lower_x_escapes", + expr: 'b""" \\x00 \\x0A \\x7F \\xFF """', + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "single_quoted_upper_x_escapes", + expr: "b' \\X00 \\X0A \\X7F \\XFF '", + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "double_quoted_upper_x_escapes", + expr: 'b" \\X00 \\X0A \\X7F \\XFF "', + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_single_quoted_upper_x_escapes", + expr: "b''' \\X00 \\X0A \\X7F \\XFF '''", + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "triple_double_quoted_upper_x_escapes", + expr: 'b""" \\X00 \\X0A \\X7F \\XFF """', + value: { bytesValue: "IAAgCiB/IP8g" }, + }, + ast: 'b" \\x00 \\n \\x7f \\xff "^#*expr.Constant_BytesValue#', + checkedAst: 'b" \\x00 \\n \\x7f \\xff "~bytes', + type: "bytes", + }, + { + original: { + name: "mixed_case_hex_single_quoted_escapes", + expr: "B' \\x4a \\x4B \\X4c \\X4D '", + value: { bytesValue: "IEogSyBMIE0g" }, + }, + ast: 'b" J K L M "^#*expr.Constant_BytesValue#', + checkedAst: 'b" J K L M "~bytes', + type: "bytes", + }, + { + original: { + name: "mixed_case_hex_double_quoted_escapes", + expr: 'B" \\x4a \\x4B \\X4c \\X4D "', + value: { bytesValue: "IEogSyBMIE0g" }, + }, + ast: 'b" J K L M "^#*expr.Constant_BytesValue#', + checkedAst: 'b" J K L M "~bytes', + type: "bytes", + }, + { + original: { + name: "mixed_case_hex_triple_single_quoted_escapes", + expr: "B''' \\x4a \\x4B \\X4c \\X4D '''", + value: { bytesValue: "IEogSyBMIE0g" }, + }, + ast: 'b" J K L M "^#*expr.Constant_BytesValue#', + checkedAst: 'b" J K L M "~bytes', + type: "bytes", + }, + { + original: { + name: "mixed_case_hex_triple_double_quoted_escapes", + expr: 'B""" \\x4a \\x4B \\X4c \\X4D """', + value: { bytesValue: "IEogSyBMIE0g" }, + }, + ast: 'b" J K L M "^#*expr.Constant_BytesValue#', + checkedAst: 'b" J K L M "~bytes', + type: "bytes", + }, + { + original: { + name: "raw_single_quoted_escapes", + expr: "br' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", + value: { + bytesValue: + "IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "raw_double_quoted_escapes", + expr: 'br" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', + value: { + bytesValue: + "IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "raw_triple_single_quoted_escapes", + expr: "br''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", + value: { + bytesValue: + "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "raw_triple_double_quoted_escapes", + expr: 'br""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', + value: { + bytesValue: + "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "upper_raw_single_quoted_escapes", + expr: "bR' \\\\ \\? \\\" \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '", + value: { + bytesValue: + "IFxcIFw/IFwiIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\\" \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "upper_raw_double_quoted_escapes", + expr: 'bR" \\\\ \\? \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 "', + value: { + bytesValue: + "IFxcIFw/IFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "upper_raw_triple_single_quoted_escapes", + expr: "bR''' \\\\ \\? \\\" \\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 '''", + value: { + bytesValue: + "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + { + original: { + name: "upper_raw_triple_double_quoted_escapes", + expr: 'bR""" \\\\ \\? \\" \\\' \\` \\a \\b \\f \\t \\v \\n \\r \\000 \\x00 \\X00 \\u0000 \\U00000000 """', + value: { + bytesValue: + "IFxcIFw/IFwiIFwnIFxgIFxhIFxiIFxmIFx0IFx2IFxuIFxyIFwwMDAgXHgwMCBcWDAwIFx1MDAwMCBcVTAwMDAwMDAwIA==", + }, + }, + ast: 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "^#*expr.Constant_BytesValue#', + checkedAst: + 'b" \\\\\\\\ \\\\? \\\\\\" \\\\\' \\\\` \\\\a \\\\b \\\\f \\\\t \\\\v \\\\n \\\\r \\\\000 \\\\x00 \\\\X00 \\\\u0000 \\\\U00000000 "~bytes', + type: "bytes", + }, + ], + }, + { + name: "whitespace", + tests: [ + { + original: { + name: "spaces", + description: "Check that spaces are ignored.", + expr: "[ . cel. expr .conformance. proto3. TestAllTypes { single_int64 : int ( 17 ) } . single_int64 ] [ 0 ] == ( 18 - 1 ) \u0026\u0026 ! false ? 1 : 2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + { + original: { + name: "tabs", + description: "Check that tabs (`\\t`) are ignored.", + expr: "[\t.\tcel.\texpr\t.conformance.\tproto3.\tTestAllTypes\t{\tsingle_int64\t:\tint\t(\t17\t)\t}\t.\tsingle_int64\t]\t[\t0\t]\t==\t(\t18\t-\t1\t)\t\u0026\u0026\t!\tfalse\t?\t1\t:\t2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + { + original: { + name: "new_lines", + description: "Check that new lines (`\\n`) are ignored.", + expr: "[\n.\ncel.\nexpr\n.conformance.\nproto3.\nTestAllTypes\n{\nsingle_int64\n:\nint\n(\n17\n)\n}\n.\nsingle_int64\n]\n[\n0\n]\n==\n(\n18\n-\n1\n)\n\u0026\u0026\n!\nfalse\n?\n1\n:\n2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + { + original: { + name: "new_pages", + description: "Check that new pages (`\\f`) are ignored.", + expr: "[\f.\fcel.\fexpr\f.conformance.\fproto3.\fTestAllTypes\f{\fsingle_int64\f:\fint\f(\f17\f)\f}\f.\fsingle_int64\f]\f[\f0\f]\f==\f(\f18\f-\f1\f)\f\u0026\u0026\f!\ffalse\f?\f1\f:\f2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + { + original: { + name: "carriage_returns", + description: "Check that carriage returns (`\\r`) are ignored.", + expr: "[\r.\rcel.\rexpr\r.conformance.\rproto3.\rTestAllTypes\r{\rsingle_int64\r:\rint\r(\r17\r)\r}\r.\rsingle_int64\r]\r[\r0\r]\r==\r(\r18\r-\r1\r)\r\u0026\u0026\r!\rfalse\r?\r1\r:\r2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + ], + }, + { + name: "comments", + tests: [ + { + original: { + name: "new_line_terminated", + description: + "Check that new-line-terminated comments are ignored.", + expr: "[// @\n.// @\ncel.// @\nexpr// @\n.conformance.// @\nproto3.// @\nTestAllTypes// @\n{// @\nsingle_int64// @\n:// @\nint// @\n(// @\n17// @\n)// @\n}// @\n.// @\nsingle_int64// @\n]// @\n[// @\n0// @\n]// @\n==// @\n(// @\n18// @\n-// @\n1// @\n)// @\n\u0026\u0026// @\n!// @\nfalse// @\n?// @\n1// @\n:// @\n2", + value: { int64Value: "1" }, + }, + ast: "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n .cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n _-_(\n 18^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n !_(\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n _\u0026\u0026_(\n _==_(\n _[_](\n [\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64:int(\n 17~int\n )~int^int64_to_int64\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int\n ]~list(int),\n 0~int\n )~int^index_list,\n _-_(\n 18~int,\n 1~int\n )~int^subtract_int64\n )~bool^equals,\n !_(\n false~bool\n )~bool^logical_not\n )~bool^logical_and,\n 1~int,\n 2~int\n)~int^conditional", + type: "int", + }, + ], + }, + { + name: "selectors", + tests: [ + { + original: { + name: "as", + description: "Check that `as` can be used as a selector.", + expr: "{ 'as': 1 }.as", + value: { int64Value: "1" }, + }, + ast: '{\n "as"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.as^#*expr.Expr_SelectExpr#', + checkedAst: '{\n "as"~string:1~int\n}~map(string, int).as~int', + type: "int", + }, + { + original: { + name: "break", + description: "Check that `break` can be used as a selector.", + expr: "{ 'break': 1 }.break", + value: { int64Value: "1" }, + }, + ast: '{\n "break"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.break^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "break"~string:1~int\n}~map(string, int).break~int', + type: "int", + }, + { + original: { + name: "const", + description: "Check that `const` can be used as a selector.", + expr: "{ 'const': 1 }.const", + value: { int64Value: "1" }, + }, + ast: '{\n "const"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.const^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "const"~string:1~int\n}~map(string, int).const~int', + type: "int", + }, + { + original: { + name: "continue", + description: "Check that `continue` can be used as a selector.", + expr: "{ 'continue': 1 }.continue", + value: { int64Value: "1" }, + }, + ast: '{\n "continue"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.continue^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "continue"~string:1~int\n}~map(string, int).continue~int', + type: "int", + }, + { + original: { + name: "else", + description: "Check that `else` can be used as a selector.", + expr: "{ 'else': 1 }.else", + value: { int64Value: "1" }, + }, + ast: '{\n "else"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.else^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "else"~string:1~int\n}~map(string, int).else~int', + type: "int", + }, + { + original: { + name: "for", + description: "Check that `for` can be used as a selector.", + expr: "{ 'for': 1 }.for", + value: { int64Value: "1" }, + }, + ast: '{\n "for"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.for^#*expr.Expr_SelectExpr#', + checkedAst: '{\n "for"~string:1~int\n}~map(string, int).for~int', + type: "int", + }, + { + original: { + name: "function", + description: "Check that `function` can be used as a selector.", + expr: "{ 'function': 1 }.function", + value: { int64Value: "1" }, + }, + ast: '{\n "function"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.function^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "function"~string:1~int\n}~map(string, int).function~int', + type: "int", + }, + { + original: { + name: "if", + description: "Check that `if` can be used as a selector.", + expr: "{ 'if': 1 }.if", + value: { int64Value: "1" }, + }, + ast: '{\n "if"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.if^#*expr.Expr_SelectExpr#', + checkedAst: '{\n "if"~string:1~int\n}~map(string, int).if~int', + type: "int", + }, + { + original: { + name: "import", + description: "Check that `import` can be used as a selector.", + expr: "{ 'import': 1 }.import", + value: { int64Value: "1" }, + }, + ast: '{\n "import"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.import^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "import"~string:1~int\n}~map(string, int).import~int', + type: "int", + }, + { + original: { + name: "let", + description: "Check that `let` can be used as a selector.", + expr: "{ 'let': 1 }.let", + value: { int64Value: "1" }, + }, + ast: '{\n "let"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.let^#*expr.Expr_SelectExpr#', + checkedAst: '{\n "let"~string:1~int\n}~map(string, int).let~int', + type: "int", + }, + { + original: { + name: "loop", + description: "Check that `loop` can be used as a selector.", + expr: "{ 'loop': 1 }.loop", + value: { int64Value: "1" }, + }, + ast: '{\n "loop"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.loop^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "loop"~string:1~int\n}~map(string, int).loop~int', + type: "int", + }, + { + original: { + name: "package", + description: "Check that `package` can be used as a selector.", + expr: "{ 'package': 1 }.package", + value: { int64Value: "1" }, + }, + ast: '{\n "package"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.package^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "package"~string:1~int\n}~map(string, int).package~int', + type: "int", + }, + { + original: { + name: "namespace", + description: + "Check that `namespace` can be used as a selector.", + expr: "{ 'namespace': 1 }.namespace", + value: { int64Value: "1" }, + }, + ast: '{\n "namespace"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.namespace^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "namespace"~string:1~int\n}~map(string, int).namespace~int', + type: "int", + }, + { + original: { + name: "return", + description: "Check that `return` can be used as a selector.", + expr: "{ 'return': 1 }.return", + value: { int64Value: "1" }, + }, + ast: '{\n "return"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.return^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "return"~string:1~int\n}~map(string, int).return~int', + type: "int", + }, + { + original: { + name: "var", + description: "Check that `var` can be used as a selector.", + expr: "{ 'var': 1 }.var", + value: { int64Value: "1" }, + }, + ast: '{\n "var"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.var^#*expr.Expr_SelectExpr#', + checkedAst: '{\n "var"~string:1~int\n}~map(string, int).var~int', + type: "int", + }, + { + original: { + name: "void", + description: "Check that `void` can be used as a selector.", + expr: "{ 'void': 1 }.void", + value: { int64Value: "1" }, + }, + ast: '{\n "void"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.void^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "void"~string:1~int\n}~map(string, int).void~int', + type: "int", + }, + { + original: { + name: "while", + description: "Check that `while` can be used as a selector.", + expr: "{ 'while': 1 }.while", + value: { int64Value: "1" }, + }, + ast: '{\n "while"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.while^#*expr.Expr_SelectExpr#', + checkedAst: + '{\n "while"~string:1~int\n}~map(string, int).while~int', + type: "int", + }, + ], + }, + { + name: "receiver_function_names", + tests: [ + { + original: { + name: "as", + description: + "Check that `as` can be used as a receiver function.", + expr: "a.as() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.as()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.as() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'as' (in container '')\n | a.as() || true\n | ....^", + }, + { + original: { + name: "break", + description: + "Check that `break` can be used as a receiver function.", + expr: "a.break() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.break()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.break() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'break' (in container '')\n | a.break() || true\n | .......^", + }, + { + original: { + name: "const", + description: + "Check that `const` can be used as a receiver function.", + expr: "a.const() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.const()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.const() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'const' (in container '')\n | a.const() || true\n | .......^", + }, + { + original: { + name: "continue", + description: + "Check that `continue` can be used as a receiver function.", + expr: "a.continue() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.continue()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.continue() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'continue' (in container '')\n | a.continue() || true\n | ..........^", + }, + { + original: { + name: "else", + description: + "Check that `else` can be used as a receiver function.", + expr: "a.else() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.else()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.else() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'else' (in container '')\n | a.else() || true\n | ......^", + }, + { + original: { + name: "for", + description: + "Check that `for` can be used as a receiver function.", + expr: "a.for() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.for()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.for() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'for' (in container '')\n | a.for() || true\n | .....^", + }, + { + original: { + name: "function", + description: + "Check that `function` can be used as a receiver function.", + expr: "a.function() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.function()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.function() || true\n | ^\nERROR: \u003cinput\u003e:1:11: undeclared reference to 'function' (in container '')\n | a.function() || true\n | ..........^", + }, + { + original: { + name: "if", + description: + "Check that `if` can be used as a receiver function.", + expr: "a.if() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.if()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.if() || true\n | ^\nERROR: \u003cinput\u003e:1:5: undeclared reference to 'if' (in container '')\n | a.if() || true\n | ....^", + }, + { + original: { + name: "import", + description: + "Check that `import` can be used as a receiver function.", + expr: "a.import() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.import()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.import() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'import' (in container '')\n | a.import() || true\n | ........^", + }, + { + original: { + name: "let", + description: + "Check that `let` can be used as a receiver function.", + expr: "a.let() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.let()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.let() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'let' (in container '')\n | a.let() || true\n | .....^", + }, + { + original: { + name: "loop", + description: + "Check that `loop` can be used as a receiver function.", + expr: "a.loop() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.loop()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.loop() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'loop' (in container '')\n | a.loop() || true\n | ......^", + }, + { + original: { + name: "package", + description: + "Check that `package` can be used as a receiver function.", + expr: "a.package() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.package()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.package() || true\n | ^\nERROR: \u003cinput\u003e:1:10: undeclared reference to 'package' (in container '')\n | a.package() || true\n | .........^", + }, + { + original: { + name: "namespace", + description: + "Check that `namespace` can be used as a receiver function.", + expr: "a.namespace() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.namespace()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.namespace() || true\n | ^\nERROR: \u003cinput\u003e:1:12: undeclared reference to 'namespace' (in container '')\n | a.namespace() || true\n | ...........^", + }, + { + original: { + name: "return", + description: + "Check that `return` can be used as a receiver function.", + expr: "a.return() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.return()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.return() || true\n | ^\nERROR: \u003cinput\u003e:1:9: undeclared reference to 'return' (in container '')\n | a.return() || true\n | ........^", + }, + { + original: { + name: "var", + description: + "Check that `var` can be used as a receiver function.", + expr: "a.var() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.var()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.var() || true\n | ^\nERROR: \u003cinput\u003e:1:6: undeclared reference to 'var' (in container '')\n | a.var() || true\n | .....^", + }, + { + original: { + name: "void", + description: + "Check that `void` can be used as a receiver function.", + expr: "a.void() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.void()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.void() || true\n | ^\nERROR: \u003cinput\u003e:1:7: undeclared reference to 'void' (in container '')\n | a.void() || true\n | ......^", + }, + { + original: { + name: "while", + description: + "Check that `while` can be used as a receiver function.", + expr: "a.while() || true", + disableCheck: true, + value: { boolValue: true }, + }, + ast: "_||_(\n a^#*expr.Expr_IdentExpr#.while()^#*expr.Expr_CallExpr#,\n true^#*expr.Constant_BoolValue#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:1: undeclared reference to 'a' (in container '')\n | a.while() || true\n | ^\nERROR: \u003cinput\u003e:1:8: undeclared reference to 'while' (in container '')\n | a.while() || true\n | .......^", + }, + ], + }, + { + name: "struct_field_names", + tests: [ + { + original: { + name: "as", + description: + "Check that `as` can be used as a struct field name.", + expr: "TestAllTypes{ as: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + as: true, + }, + }, + }, + ast: "TestAllTypes{\n as:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n as:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "break", + description: + "Check that `break` can be used as a struct field name.", + expr: "TestAllTypes{ break: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + break: true, + }, + }, + }, + ast: "TestAllTypes{\n break:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n break:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "const", + description: + "Check that `const` can be used as a struct field name.", + expr: "TestAllTypes{ const: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + const: true, + }, + }, + }, + ast: "TestAllTypes{\n const:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n const:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "continue", + description: + "Check that `continue` can be used as a struct field name.", + expr: "TestAllTypes{ continue: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + continue: true, + }, + }, + }, + ast: "TestAllTypes{\n continue:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n continue:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "else", + description: + "Check that `else` can be used as a struct field name.", + expr: "TestAllTypes{ else: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + else: true, + }, + }, + }, + ast: "TestAllTypes{\n else:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n else:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "for", + description: + "Check that `for` can be used as a struct field name.", + expr: "TestAllTypes{ for: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + for: true, + }, + }, + }, + ast: "TestAllTypes{\n for:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n for:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "function", + description: + "Check that `function` can be used as a struct field name.", + expr: "TestAllTypes{ function: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + function: true, + }, + }, + }, + ast: "TestAllTypes{\n function:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n function:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "if", + description: + "Check that `if` can be used as a struct field name.", + expr: "TestAllTypes{ if: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + if: true, + }, + }, + }, + ast: "TestAllTypes{\n if:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n if:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "import", + description: + "Check that `import` can be used as a struct field name.", + expr: "TestAllTypes{ import: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + import: true, + }, + }, + }, + ast: "TestAllTypes{\n import:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n import:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "let", + description: + "Check that `let` can be used as a struct field name.", + expr: "TestAllTypes{ let: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + let: true, + }, + }, + }, + ast: "TestAllTypes{\n let:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n let:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "loop", + description: + "Check that `loop` can be used as a struct field name.", + expr: "TestAllTypes{ loop: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + loop: true, + }, + }, + }, + ast: "TestAllTypes{\n loop:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n loop:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "package", + description: + "Check that `package` can be used as a struct field name.", + expr: "TestAllTypes{ package: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + package: true, + }, + }, + }, + ast: "TestAllTypes{\n package:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n package:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "namespace", + description: + "Check that `namespace` can be used as a struct field name.", + expr: "TestAllTypes{ namespace: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + namespace: true, + }, + }, + }, + ast: "TestAllTypes{\n namespace:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n namespace:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "return", + description: + "Check that `return` can be used as a struct field name.", + expr: "TestAllTypes{ return: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + return: true, + }, + }, + }, + ast: "TestAllTypes{\n return:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n return:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "var", + description: + "Check that `var` can be used as a struct field name.", + expr: "TestAllTypes{ var: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + var: true, + }, + }, + }, + ast: "TestAllTypes{\n var:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n var:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "void", + description: + "Check that `void` can be used as a struct field name.", + expr: "TestAllTypes{ void: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + void: true, + }, + }, + }, + ast: "TestAllTypes{\n void:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n void:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "while", + description: + "Check that `while` can be used as a struct field name.", + expr: "TestAllTypes{ while: true }", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + while: true, + }, + }, + }, + ast: "TestAllTypes{\n while:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n while:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + ], + }, + { + name: "plumbing", + suites: [ + { + name: "min", + tests: [ + { + original: { + name: "min_program", + description: "Smallest functionality: expr in, result out.", + expr: "17", + value: { int64Value: "17" }, + }, + ast: "17^#*expr.Constant_Int64Value#", + checkedAst: "17~int", + type: "int", + }, + ], + }, + { + name: "eval_results", + tests: [ + { + original: { + name: "error_result", + description: "Check that error results go through.", + expr: "1 / 0", + evalError: { errors: [{ message: "foo" }] }, + }, + ast: "_/_(\n 1^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: "_/_(\n 1~int,\n 0~int\n)~int^divide_int64", + type: "int", + }, + { + original: { + name: "eval_map_results", + description: + "Check that map literals results are order independent.", + expr: '{"k1":"v1","k":"v"}', + value: { + mapValue: { + entries: [ + { + key: { stringValue: "k" }, + value: { stringValue: "v" }, + }, + { + key: { stringValue: "k1" }, + value: { stringValue: "v1" }, + }, + ], + }, + }, + }, + ast: '{\n "k1"^#*expr.Constant_StringValue#:"v1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "k"^#*expr.Constant_StringValue#:"v"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + '{\n "k1"~string:"v1"~string,\n "k"~string:"v"~string\n}~map(string, string)', + type: "map(string, string)", + }, + ], + }, + { + name: "check_inputs", + tests: [ + { + original: { + name: "skip_check", + description: "Make sure we can skip type checking.", + expr: "[17, 'pancakes']", + disableCheck: true, + value: { + listValue: { + values: [{ int64Value: "17" }, { stringValue: "pancakes" }], + }, + }, + }, + ast: '[\n 17^#*expr.Constant_Int64Value#,\n "pancakes"^#*expr.Constant_StringValue#\n]^#*expr.Expr_ListExpr#', + checkedAst: '[\n 17~int,\n "pancakes"~string\n]~list(dyn)', + type: "list(dyn)", + }, + ], + }, + { + name: "eval_inputs", + tests: [ + { + original: { + name: "one_ignored_value_arg", + description: + "Check that value bindings can be given, even if ignored.", + expr: "'foo'", + bindings: { x: { value: { int64Value: "17" } } }, + value: { stringValue: "foo" }, + }, + ast: '"foo"^#*expr.Constant_StringValue#', + checkedAst: '"foo"~string', + type: "string", + }, + ], + }, + ], + }, + { + name: "proto2", + suites: [ + { + name: "literal_singular", + tests: [ + { + original: { + name: "int64_nocontainer", + expr: "cel.expr.conformance.proto2.TestAllTypes{single_int64: 17}", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt64: "17", + }, + }, + }, + ast: "cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "int32", + expr: "TestAllTypes{single_int32: -34}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: -34, + }, + }, + }, + ast: "TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "int32_eq_uint", + expr: "Int32Value{value: 34} == dyn(UInt64Value{value: 34u})", + container: "google.protobuf", + value: { boolValue: true }, + }, + ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_int32_eq_uint", + expr: "Int32Value{value: 34} == dyn(UInt64Value{value: 18446744073709551615u})", + container: "google.protobuf", + value: { boolValue: false }, + }, + ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "int32_eq_double", + expr: "Int32Value{value: 34} == dyn(DoubleValue{value: 34.0})", + container: "google.protobuf", + value: { boolValue: true }, + }, + ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_int32_eq_double", + expr: "Int32Value{value: 34} == dyn(DoubleValue{value: -9223372036854775809.0})", + container: "google.protobuf", + value: { boolValue: false }, + }, + ast: "_==_(\n Int32Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:-9.223372036854776e+18^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.Int32Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:-9.223372036854776e+18~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "int64", + expr: "TestAllTypes{single_int64: 17}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt64: "17", + }, + }, + }, + ast: "TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "uint32", + expr: "TestAllTypes{single_uint32: 1u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint32: 1, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "uint32_eq_int", + expr: "UInt32Value{value: 34u} == dyn(Int64Value{value: 34})", + container: "google.protobuf", + value: { boolValue: true }, + }, + ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:34~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_uint32_eq_int", + expr: "UInt32Value{value: 34u} == dyn(Int64Value{value: -1})", + container: "google.protobuf", + value: { boolValue: false }, + }, + ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "uint32_eq_double", + expr: "UInt32Value{value: 34u} == dyn(DoubleValue{value: 34.0})", + container: "google.protobuf", + value: { boolValue: true }, + }, + ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:34~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_uint32_eq_double", + expr: "UInt32Value{value: 34u} == dyn(DoubleValue{value: 18446744073709551616.0})", + container: "google.protobuf", + value: { boolValue: false }, + }, + ast: "_==_(\n UInt32Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n DoubleValue{\n value:1.8446744073709552e+19^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.UInt32Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value,\n dyn(\n google.protobuf.DoubleValue{\n value:1.8446744073709552e+19~double\n }~wrapper(double)^google.protobuf.DoubleValue\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "uint64", + expr: "TestAllTypes{single_uint64: 9999u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint64: "9999", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "sint32", + expr: "TestAllTypes{single_sint32: -3}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleSint32: -3, + }, + }, + }, + ast: "TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "sint64", + expr: "TestAllTypes{single_sint64: 255}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleSint64: "255", + }, + }, + }, + ast: "TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "fixed32", + expr: "TestAllTypes{single_fixed32: 43u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFixed32: 43, + }, + }, + }, + ast: "TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "fixed64", + expr: "TestAllTypes{single_fixed64: 1880u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFixed64: "1880", + }, + }, + }, + ast: "TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "sfixed32", + expr: "TestAllTypes{single_sfixed32: -404}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleSfixed32: -404, + }, + }, + }, + ast: "TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "sfixed64", + expr: "TestAllTypes{single_sfixed64: -1}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleSfixed64: "-1", + }, + }, + }, + ast: "TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "float", + expr: "TestAllTypes{single_float: 3.1416}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloat: 3.1416, + }, + }, + }, + ast: "TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "float_eq_int", + expr: "FloatValue{value: 3.0} == dyn(Int64Value{value: 3})", + container: "google.protobuf", + value: { boolValue: true }, + }, + ast: "_==_(\n FloatValue{\n value:3^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{\n value:3~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:3~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_float_eq_int", + expr: "FloatValue{value: -1.14} == dyn(Int64Value{value: -1})", + container: "google.protobuf", + value: { boolValue: false }, + }, + ast: "_==_(\n FloatValue{\n value:-1.14^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n Int64Value{\n value:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{\n value:-1.14~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.Int64Value{\n value:-1~int\n }~wrapper(int)^google.protobuf.Int64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "float_eq_uint", + expr: "FloatValue{value: 34.0} == dyn(UInt64Value{value: 34u})", + container: "google.protobuf", + value: { boolValue: true }, + }, + ast: "_==_(\n FloatValue{\n value:34^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:34u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{\n value:34~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:34u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "not_float_eq_uint", + expr: "FloatValue{value: -1.0} == dyn(UInt64Value{value: 18446744073709551615u})", + container: "google.protobuf", + value: { boolValue: false }, + }, + ast: "_==_(\n FloatValue{\n value:-1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n dyn(\n UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n google.protobuf.FloatValue{\n value:-1~double\n }~wrapper(double)^google.protobuf.FloatValue,\n dyn(\n google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n )~dyn^to_dyn\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "double", + expr: "TestAllTypes{single_double: 6.022e23}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleDouble: 6.022e23, + }, + }, + }, + ast: "TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "bool", + expr: "TestAllTypes{single_bool: true}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBool: true, + }, + }, + }, + ast: "TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "string", + expr: "TestAllTypes{single_string: 'foo'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleString: "foo", + }, + }, + }, + ast: 'TestAllTypes{\n single_string:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_string:"foo"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "bytes", + expr: "TestAllTypes{single_bytes: b'\\377'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBytes: "/w==", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes:b"\\xff"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes:b"\\xff"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + ], + }, + { + name: "literal_wellknown", + tests: [ + { + original: { + name: "any", + expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 1}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleAny: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 1, + }, + }, + }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_any:cel.expr.conformance.proto2.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "duration", + expr: "TestAllTypes{single_duration: duration('123s')}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleDuration: "123s", + }, + }, + }, + ast: 'TestAllTypes{\n single_duration:duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_duration:duration(\n "123s"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "timestamp", + expr: "TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleTimestamp: "2009-02-13T23:31:30Z", + }, + }, + }, + ast: 'TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "struct", + expr: "TestAllTypes{single_struct: {'one': 1, 'two': 2}}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleStruct: { one: 1, two: 2 }, + }, + }, + }, + ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_struct:{\n "one"~string:1~int,\n "two"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "value", + expr: "TestAllTypes{single_value: 'foo'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleValue: "foo", + }, + }, + }, + ast: 'TestAllTypes{\n single_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_value:"foo"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "int64_wrapper", + expr: "TestAllTypes{single_int64_wrapper: -321}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt64Wrapper: "-321", + }, + }, + }, + ast: "TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "int32_wrapper", + expr: "TestAllTypes{single_int32_wrapper: -456}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32Wrapper: -456, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "double_wrapper", + expr: "TestAllTypes{single_double_wrapper: 2.71828}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleDoubleWrapper: 2.71828, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "float_wrapper", + expr: "TestAllTypes{single_float_wrapper: 2.99792e8}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleFloatWrapper: 299792000, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "uint64_wrapper", + expr: "TestAllTypes{single_uint64_wrapper: 8675309u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint64Wrapper: "8675309", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "uint32_wrapper", + expr: "TestAllTypes{single_uint32_wrapper: 987u}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleUint32Wrapper: 987, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "string_wrapper", + expr: "TestAllTypes{single_string_wrapper: 'hubba'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleStringWrapper: "hubba", + }, + }, + }, + ast: 'TestAllTypes{\n single_string_wrapper:"hubba"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_string_wrapper:"hubba"~string\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "bool_wrapper", + expr: "TestAllTypes{single_bool_wrapper: true}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBoolWrapper: true, + }, + }, + }, + ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes", + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + { + original: { + name: "bytes_wrapper", + expr: "TestAllTypes{single_bytes_wrapper: b'\\301\\103'}", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleBytesWrapper: "wUM=", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"~bytes\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes', + type: "cel.expr.conformance.proto2.TestAllTypes", + }, + ], + }, + { + name: "singular_bind", + tests: [ + { + original: { + name: "int32", + expr: "x.single_int32", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt32: 17, + }, + }, + }, + }, + value: { int64Value: "17" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto2.TestAllTypes^x.single_int32~int", + type: "int", + }, + { + original: { + name: "int64", + expr: "x.single_int64", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + singleInt64: "-99", + }, + }, + }, + }, + value: { int64Value: "-99" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto2.TestAllTypes^x.single_int64~int", + type: "int", + }, + ], + }, + { + name: "empty_field", + tests: [ + { + original: { + name: "scalar_with_default", + expr: "TestAllTypes{}.single_int32", + container: "cel.expr.conformance.proto2", + value: { int64Value: "-32" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~int", + type: "int", + }, + { + original: { + name: "scalar_no_default", + expr: "TestAllTypes{}.single_fixed32", + container: "cel.expr.conformance.proto2", + value: { uint64Value: "0" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_fixed32~uint", + type: "uint", + }, + { + original: { + name: "nested_message", + expr: "TestAllTypes{}.single_nested_message", + container: "cel.expr.conformance.proto2", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes.NestedMessage", + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage", + type: "cel.expr.conformance.proto2.TestAllTypes.NestedMessage", + }, + { + original: { + name: "nested_message_subfield", + expr: "TestAllTypes{}.single_nested_message.bb", + container: "cel.expr.conformance.proto2", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~cel.expr.conformance.proto2.TestAllTypes.NestedMessage.bb~int", + type: "int", + }, + { + original: { + name: "wkt", + expr: "TestAllTypes{}.single_int64_wrapper", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int64_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "repeated_scalar", + expr: "TestAllTypes{}.repeated_int64", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int64~list(int)", + type: "list(int)", + }, + { + original: { + name: "repeated_enum", + expr: "TestAllTypes{}.repeated_nested_enum", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)", + type: "list(int)", + }, + { + original: { + name: "repeated_nested", + expr: "TestAllTypes{}.repeated_nested_message", + container: "cel.expr.conformance.proto2", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)", + type: "list(cel.expr.conformance.proto2.TestAllTypes.NestedMessage)", + }, + { + original: { + name: "map", + expr: "TestAllTypes{}.map_string_string", + container: "cel.expr.conformance.proto2", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~map(string, string)", + type: "map(string, string)", + }, + ], + }, + { + name: "has", + tests: [ + { + original: { + name: "undefined", + expr: "has(TestAllTypes{}.no_such_field)", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "no_such_field" }] }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^", + }, + { + original: { + name: "repeated_none_implicit", + expr: "has(TestAllTypes{}.repeated_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "repeated_none_explicit", + expr: "has(TestAllTypes{repeated_int32: []}.repeated_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "repeated_one", + expr: "has(TestAllTypes{repeated_int32: [1]}.repeated_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "repeated_many", + expr: "has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "map_none_implicit", + expr: "has(TestAllTypes{}.map_string_string)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool", + type: "bool", + }, + { + original: { + name: "map_none_explicit", + expr: "has(TestAllTypes{map_string_string: {}}.map_string_string)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool", + type: "bool", + }, + { + original: { + name: "map_one_default", + expr: "has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: 'TestAllTypes{\n map_string_string:{\n "MT"^#*expr.Constant_StringValue#:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n "MT"~string:""~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool', + type: "bool", + }, + { + original: { + name: "map_one", + expr: "has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool', + type: "bool", + }, + { + original: { + name: "map_many", + expr: "has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:"dos"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto2.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string,\n "two"~string:"dos"~string\n }~map(string, string)\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.map_string_string~test-only~~bool', + type: "bool", + }, + { + original: { + name: "required", + expr: "has(TestRequired{required_int32: 4}.required_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestRequired{\n required_int32:4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.required_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestRequired{\n required_int32:4~int\n}~cel.expr.conformance.proto2.TestRequired^cel.expr.conformance.proto2.TestRequired.required_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_unset_no_default", + expr: "has(TestAllTypes{}.single_sint32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_set_no_default", + expr: "has(TestAllTypes{single_sint32: -4}.single_sint32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_sint32:-4^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_sint32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_sint32:-4~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_sint32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_unset_with_default", + expr: "has(TestAllTypes{}.single_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_set_with_default", + expr: "has(TestAllTypes{single_int32: 16}.single_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_set_to_default", + expr: "has(TestAllTypes{single_int32: -32}.single_int32)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_int32:-32^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_int32:-32~int\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_message_unset", + expr: "has(TestAllTypes{}.standalone_message)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_message_set", + expr: "has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_enum_unset", + expr: "has(TestAllTypes{}.standalone_enum)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_enum_set", + expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool", + type: "bool", + }, + { + original: { + name: "optional_enum_set_zero", + expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.standalone_enum~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_unset", + expr: "has(TestAllTypes{}.single_nested_message)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_other_set", + expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_set", + expr: "has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto2.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto2.TestAllTypes.NestedMessage^cel.expr.conformance.proto2.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_set_default", + expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_nested_enum~test-only~~bool", + type: "bool", + }, + ], + }, + { + name: "set_null", + tests: [ + { + original: { + name: "single_message", + expr: "TestAllTypes{single_nested_message: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "single_any", + expr: "TestAllTypes{single_any: null}.single_any", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "single_value", + expr: "TestAllTypes{single_value: null}.single_value", + container: "cel.expr.conformance.proto2", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto2.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "single_duration", + expr: "TestAllTypes{single_duration: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "single_timestamp", + expr: "TestAllTypes{single_timestamp: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto2.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "single_scalar", + expr: "TestAllTypes{single_bool: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^", + }, + { + original: { + name: "repeated", + expr: "TestAllTypes{repeated_int32: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^", + }, + { + original: { + name: "map", + expr: "TestAllTypes{map_string_string: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^", + }, + { + original: { + name: "list_value", + expr: "TestAllTypes{list_value: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^", + }, + { + original: { + name: "single_struct", + expr: "TestAllTypes{single_struct: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto2", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^", + }, + ], + }, + { + name: "quoted_fields", + tests: [ + { + original: { + name: "set_field_with_quoted_name", + expr: "TestAllTypes{`in`: true} == TestAllTypes{}", + container: "cel.expr.conformance.proto2", + value: { boolValue: false }, + }, + error: + "ERROR: set_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^", + }, + { + original: { + name: "get_field_with_quoted_name", + expr: "TestAllTypes{`in`: true}.`in`", + container: "cel.expr.conformance.proto2", + value: { boolValue: true }, + }, + error: + "ERROR: get_field_with_quoted_name:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field_with_quoted_name:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^", + }, + ], + }, + { + name: "extensions_has", + tests: [ + { + original: { + name: "package_scoped_int32", + expr: "has(msg.`cel.expr.conformance.proto2.int32_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.int32_ext]": 42, + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_int32:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.int32_ext`)\n | ........^", + }, + { + original: { + name: "package_scoped_nested_ext", + expr: "has(msg.`cel.expr.conformance.proto2.nested_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_ext]": {}, + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_ext`)\n | ........^", + }, + { + original: { + name: "package_scoped_test_all_types_ext", + expr: "has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.test_all_types_ext]": {}, + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_test_all_types_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.test_all_types_ext`)\n | ........^", + }, + { + original: { + name: "package_scoped_test_all_types_nested_enum_ext", + expr: "has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_test_all_types_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.nested_enum_ext`)\n | ........^", + }, + { + original: { + name: "package_scoped_repeated_test_all_types", + expr: "has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.repeated_test_all_types`)\n | ........^", + }, + { + original: { + name: "message_scoped_int64", + expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": + "42", + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_int64:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext`)\n | ........^", + }, + { + original: { + name: "message_scoped_nested_ext", + expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": + {}, + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_nested_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext`)\n | ........^", + }, + { + original: { + name: "message_scoped_nested_enum_ext", + expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": + "BAR", + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_nested_enum_ext:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext`)\n | ........^", + }, + { + original: { + name: "message_scoped_repeated_test_all_types", + expr: "has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_repeated_test_all_types:1:9: unsupported syntax: '`'\n | has(msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types`)\n | ........^", + }, + ], + }, + { + name: "extensions_get", + tests: [ + { + original: { + name: "package_scoped_int32", + expr: "msg.`cel.expr.conformance.proto2.int32_ext` == 42", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.int32_ext]": 42, + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_int32:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.int32_ext` == 42\n | ....^", + }, + { + original: { + name: "package_scoped_nested_ext", + expr: "msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_ext]": {}, + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^", + }, + { + original: { + name: "package_scoped_test_all_types_ext", + expr: "msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.test_all_types_ext]": {}, + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_test_all_types_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.test_all_types_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^", + }, + { + original: { + name: "package_scoped_test_all_types_nested_enum_ext", + expr: "msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_test_all_types_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^", + }, + { + original: { + name: "package_scoped_repeated_test_all_types", + expr: "msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + error: + "ERROR: package_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^", + }, + { + original: { + name: "message_scoped_int64", + expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": + "42", + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_int64:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext` == 42\n | ....^", + }, + { + original: { + name: "message_scoped_nested_ext", + expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": + {}, + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_nested_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext` == cel.expr.conformance.proto2.TestAllTypes{}\n | ....^", + }, + { + original: { + name: "message_scoped_nested_enum_ext", + expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": + "BAR", + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_nested_enum_ext:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext` == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n | ....^", + }, + { + original: { + name: "message_scoped_repeated_test_all_types", + expr: "msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + error: + "ERROR: message_scoped_repeated_test_all_types:1:5: unsupported syntax: '`'\n | msg.`cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types` == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]\n | ....^", + }, + ], + }, + ], + }, + { + name: "proto2_ext", + suites: [ + { + name: "has_ext", + tests: [ + { + original: { + name: "package_scoped_int32", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.int32_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.int32_ext]": 42, + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "package_scoped_nested_ext", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.nested_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_ext]": {}, + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "package_scoped_test_all_types_ext", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.test_all_types_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.test_all_types_ext]": {}, + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "package_scoped_test_all_types_nested_enum_ext", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.nested_enum_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "package_scoped_repeated_test_all_types", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.repeated_test_all_types)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~test-only~~bool", + type: "bool", + }, + { + original: { + name: "message_scoped_int64", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": + "42", + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "message_scoped_nested_ext", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": + {}, + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "message_scoped_nested_enum_ext", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": + "BAR", + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~test-only~~bool", + type: "bool", + }, + { + original: { + name: "message_scoped_repeated_test_all_types", + expr: "proto.hasExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types)", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + ast: "proto^#*expr.Expr_IdentExpr#.hasExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~test-only~~bool", + type: "bool", + }, + ], + }, + { + name: "get_ext", + tests: [ + { + original: { + name: "package_scoped_int32", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.int32_ext) == 42", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.int32_ext]": 42, + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.int32_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.int32_ext~int,\n 42~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "package_scoped_nested_ext", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_ext]": {}, + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "package_scoped_test_all_types_ext", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.test_all_types_ext) == cel.expr.conformance.proto2.TestAllTypes{}", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.test_all_types_ext]": {}, + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.test_all_types_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.test_all_types_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "package_scoped_test_all_types_nested_enum_ext", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.nested_enum_ext]": "BAR", + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "package_scoped_repeated_test_all_types", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "message_scoped_int64", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext) == 42", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext]": + "42", + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.int64_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext~int,\n 42~int\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "message_scoped_nested_ext", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext) == cel.expr.conformance.proto2.TestAllTypes{}", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]": + {}, + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_nested_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel.expr.conformance.proto2.TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext~cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "message_scoped_nested_enum_ext", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext) == cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext]": + "BAR", + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.nested_enum_ext^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.TestAllTypes^#*expr.Expr_SelectExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext~int,\n cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "message_scoped_repeated_test_all_types", + expr: "proto.getExt(msg, cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types) == [cel.expr.conformance.proto2.TestAllTypes{single_int64: 1}, cel.expr.conformance.proto2.TestAllTypes{single_bool: true}]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto2.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes", + "[cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types]": + [{ singleInt64: "1" }, { singleBool: true }], + }, + }, + }, + }, + }, + ast: "_==_(\n proto^#*expr.Expr_IdentExpr#.getExt(\n msg^#*expr.Expr_IdentExpr#,\n cel^#*expr.Expr_IdentExpr#.expr^#*expr.Expr_SelectExpr#.conformance^#*expr.Expr_SelectExpr#.proto2^#*expr.Expr_SelectExpr#.Proto2ExtensionScopedMessage^#*expr.Expr_SelectExpr#.message_scoped_repeated_test_all_types^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto2.TestAllTypes^msg.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types~list(cel.expr.conformance.proto2.TestAllTypes),\n [\n cel.expr.conformance.proto2.TestAllTypes{\n single_int64:1~int\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes,\n cel.expr.conformance.proto2.TestAllTypes{\n single_bool:true~bool\n }~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes\n ]~list(cel.expr.conformance.proto2.TestAllTypes)\n)~bool^equals", + type: "bool", + }, + ], + }, + ], + }, + { + name: "proto3", + suites: [ + { + name: "literal_singular", + tests: [ + { + original: { + name: "int64_nocontainer", + expr: "cel.expr.conformance.proto3.TestAllTypes{single_int64: 17}", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64: "17", + }, + }, + }, + ast: "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "int32", + expr: "TestAllTypes{single_int32: -34}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: -34, + }, + }, + }, + ast: "TestAllTypes{\n single_int32:-34^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32:-34~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "int64", + expr: "TestAllTypes{single_int64: 17}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64: "17", + }, + }, + }, + ast: "TestAllTypes{\n single_int64:17^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:17~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "uint32", + expr: "TestAllTypes{single_uint32: 1u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint32: 1, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32:1u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "uint64", + expr: "TestAllTypes{single_uint64: 9999u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint64: "9999", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64:9999u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64:9999u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "sint32", + expr: "TestAllTypes{single_sint32: -3}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleSint32: -3, + }, + }, + }, + ast: "TestAllTypes{\n single_sint32:-3^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_sint32:-3~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "sint64", + expr: "TestAllTypes{single_sint64: 255}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleSint64: "255", + }, + }, + }, + ast: "TestAllTypes{\n single_sint64:255^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_sint64:255~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "fixed32", + expr: "TestAllTypes{single_fixed32: 43u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFixed32: 43, + }, + }, + }, + ast: "TestAllTypes{\n single_fixed32:43u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_fixed32:43u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "fixed64", + expr: "TestAllTypes{single_fixed64: 1880u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFixed64: "1880", + }, + }, + }, + ast: "TestAllTypes{\n single_fixed64:1880u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_fixed64:1880u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "sfixed32", + expr: "TestAllTypes{single_sfixed32: -404}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleSfixed32: -404, + }, + }, + }, + ast: "TestAllTypes{\n single_sfixed32:-404^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed32:-404~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "sfixed64", + expr: "TestAllTypes{single_sfixed64: -1}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleSfixed64: "-1", + }, + }, + }, + ast: "TestAllTypes{\n single_sfixed64:-1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_sfixed64:-1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "float", + expr: "TestAllTypes{single_float: 3.1416}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFloat: 3.1416, + }, + }, + }, + ast: "TestAllTypes{\n single_float:3.1416^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float:3.1416~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "double", + expr: "TestAllTypes{single_double: 6.022e23}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleDouble: 6.022e23, + }, + }, + }, + ast: "TestAllTypes{\n single_double:6.022e+23^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double:6.022e+23~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "bool", + expr: "TestAllTypes{single_bool: true}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBool: true, + }, + }, + }, + ast: "TestAllTypes{\n single_bool:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_bool:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "string", + expr: "TestAllTypes{single_string: 'foo'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleString: "foo", + }, + }, + }, + ast: 'TestAllTypes{\n single_string:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_string:"foo"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "bytes", + expr: "TestAllTypes{single_bytes: b'\\377'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBytes: "/w==", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes:b"\\xff"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes:b"\\xff"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "literal_wellknown", + tests: [ + { + original: { + name: "any", + expr: "TestAllTypes{single_any: TestAllTypes{single_int32: 1}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleAny: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 1, + }, + }, + }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{\n single_int32:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{\n single_int32:1~int\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "duration", + expr: "TestAllTypes{single_duration: duration('123s')}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleDuration: "123s", + }, + }, + }, + ast: 'TestAllTypes{\n single_duration:duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_duration:duration(\n "123s"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "timestamp", + expr: "TestAllTypes{single_timestamp: timestamp('2009-02-13T23:31:30Z')}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleTimestamp: "2009-02-13T23:31:30Z", + }, + }, + }, + ast: 'TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "struct", + expr: "TestAllTypes{single_struct: {'one': 1, 'two': 2}}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleStruct: { one: 1, two: 2 }, + }, + }, + }, + ast: 'TestAllTypes{\n single_struct:{\n "one"^#*expr.Constant_StringValue#:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:2^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_struct:{\n "one"~string:1~int,\n "two"~string:2~int\n }~map(string, int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "value", + expr: "TestAllTypes{single_value: 'foo'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleValue: "foo", + }, + }, + }, + ast: 'TestAllTypes{\n single_value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:"foo"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "int64_wrapper", + expr: "TestAllTypes{single_int64_wrapper: -321}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64Wrapper: "-321", + }, + }, + }, + ast: "TestAllTypes{\n single_int64_wrapper:-321^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:-321~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "int32_wrapper", + expr: "TestAllTypes{single_int32_wrapper: -456}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32Wrapper: -456, + }, + }, + }, + ast: "TestAllTypes{\n single_int32_wrapper:-456^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:-456~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "double_wrapper", + expr: "TestAllTypes{single_double_wrapper: 2.71828}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleDoubleWrapper: 2.71828, + }, + }, + }, + ast: "TestAllTypes{\n single_double_wrapper:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:2.71828~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "float_wrapper", + expr: "TestAllTypes{single_float_wrapper: 2.99792e8}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleFloatWrapper: 299792000, + }, + }, + }, + ast: "TestAllTypes{\n single_float_wrapper:2.99792e+08^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:2.99792e+08~double\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "uint64_wrapper", + expr: "TestAllTypes{single_uint64_wrapper: 8675309u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint64Wrapper: "8675309", + }, + }, + }, + ast: "TestAllTypes{\n single_uint64_wrapper:8675309u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:8675309u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "uint32_wrapper", + expr: "TestAllTypes{single_uint32_wrapper: 987u}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleUint32Wrapper: 987, + }, + }, + }, + ast: "TestAllTypes{\n single_uint32_wrapper:987u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:987u~uint\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "string_wrapper", + expr: "TestAllTypes{single_string_wrapper: 'hubba'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleStringWrapper: "hubba", + }, + }, + }, + ast: 'TestAllTypes{\n single_string_wrapper:"hubba"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:"hubba"~string\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "bool_wrapper", + expr: "TestAllTypes{single_bool_wrapper: true}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBoolWrapper: true, + }, + }, + }, + ast: "TestAllTypes{\n single_bool_wrapper:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:true~bool\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + { + original: { + name: "bytes_wrapper", + expr: "TestAllTypes{single_bytes_wrapper: b'\\301\\103'}", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleBytesWrapper: "wUM=", + }, + }, + }, + ast: 'TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:b"\\xc1C"~bytes\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes', + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "singular_bind", + tests: [ + { + original: { + name: "int32", + expr: "x.single_int32", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt32: 17, + }, + }, + }, + }, + value: { int64Value: "17" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.single_int32^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32~int", + type: "int", + }, + { + original: { + name: "int64", + expr: "x.single_int64", + typeEnv: [ + { + name: "x", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64: "-99", + }, + }, + }, + }, + value: { int64Value: "-99" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64~int", + type: "int", + }, + ], + }, + { + name: "empty_field", + tests: [ + { + original: { + name: "scalar", + expr: "TestAllTypes{}.single_fixed32", + container: "cel.expr.conformance.proto3", + value: { uint64Value: "0" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_fixed32^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_fixed32~uint", + type: "uint", + }, + { + original: { + name: "nested_message", + expr: "TestAllTypes{}.single_nested_message", + container: "cel.expr.conformance.proto3", + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage", + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage", + type: "cel.expr.conformance.proto3.TestAllTypes.NestedMessage", + }, + { + original: { + name: "nested_message_subfield", + expr: "TestAllTypes{}.single_nested_message.bb", + container: "cel.expr.conformance.proto3", + value: { int64Value: "0" }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message^#*expr.Expr_SelectExpr#.bb^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage.bb~int", + type: "int", + }, + { + original: { + name: "wkt", + expr: "TestAllTypes{}.single_int64_wrapper", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64_wrapper~wrapper(int)", + type: "wrapper(int)", + }, + { + original: { + name: "repeated_scalar", + expr: "TestAllTypes{}.repeated_int64", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)", + type: "list(int)", + }, + { + original: { + name: "repeated_enum", + expr: "TestAllTypes{}.repeated_nested_enum", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)", + type: "list(int)", + }, + { + original: { + name: "repeated_nested", + expr: "TestAllTypes{}.repeated_nested_message", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)", + type: "list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)", + }, + { + original: { + name: "map", + expr: "TestAllTypes{}.map_string_string", + container: "cel.expr.conformance.proto3", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~map(string, string)", + type: "map(string, string)", + }, + ], + }, + { + name: "has", + tests: [ + { + original: { + name: "undefined", + expr: "has(TestAllTypes{}.no_such_field)", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "no_such_field" }] }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.no_such_field~test-only~^#*expr.Expr_SelectExpr#", + error: + "ERROR: \u003cinput\u003e:1:4: undefined field 'no_such_field'\n | has(TestAllTypes{}.no_such_field)\n | ...^", + }, + { + original: { + name: "repeated_none_implicit", + expr: "has(TestAllTypes{}.repeated_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "repeated_none_explicit", + expr: "has(TestAllTypes{repeated_int32: []}.repeated_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n repeated_int32:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "repeated_one", + expr: "has(TestAllTypes{repeated_int32: [1]}.repeated_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "repeated_many", + expr: "has(TestAllTypes{repeated_int32: [1, 2, 3]}.repeated_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n repeated_int32:[\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.repeated_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n repeated_int32:[\n 1~int,\n 2~int,\n 3~int\n ]~list(int)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "map_none_implicit", + expr: "has(TestAllTypes{}.map_string_string)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool", + type: "bool", + }, + { + original: { + name: "map_none_explicit", + expr: "has(TestAllTypes{map_string_string: {}}.map_string_string)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n map_string_string:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{}~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool", + type: "bool", + }, + { + original: { + name: "map_one_default", + expr: "has(TestAllTypes{map_string_string: {'MT': ''}}.map_string_string)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: 'TestAllTypes{\n map_string_string:{\n "MT"^#*expr.Constant_StringValue#:""^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n "MT"~string:""~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool', + type: "bool", + }, + { + original: { + name: "map_one", + expr: "has(TestAllTypes{map_string_string: {'one': 'uno'}}.map_string_string)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool', + type: "bool", + }, + { + original: { + name: "map_many", + expr: "has(TestAllTypes{map_string_string: {'one': 'uno', 'two': 'dos'}}.map_string_string)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: 'TestAllTypes{\n map_string_string:{\n "one"^#*expr.Constant_StringValue#:"uno"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n "two"^#*expr.Constant_StringValue#:"dos"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.map_string_string~test-only~^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n map_string_string:{\n "one"~string:"uno"~string,\n "two"~string:"dos"~string\n }~map(string, string)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_string_string~test-only~~bool', + type: "bool", + }, + { + original: { + name: "single_unset", + expr: "has(TestAllTypes{}.single_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_set", + expr: "has(TestAllTypes{single_int32: 16}.single_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_int32:16^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32:16~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_set_to_default", + expr: "has(TestAllTypes{single_int32: 0}.single_int32)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n single_int32:0^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int32~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int32:0~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int32~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_message_unset", + expr: "has(TestAllTypes{}.standalone_message)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_message_set", + expr: "has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{bb: 123}}.standalone_message)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{\n bb:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{\n bb:123~int\n }~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_message_set_to_default", + expr: "has(TestAllTypes{standalone_message: TestAllTypes.NestedMessage{}}.standalone_message)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n standalone_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_enum_unset", + expr: "has(TestAllTypes{}.standalone_enum)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_enum_set", + expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.BAR}.standalone_enum)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAR^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool", + type: "bool", + }, + { + original: { + name: "single_enum_set_zero", + expr: "has(TestAllTypes{standalone_enum: TestAllTypes.NestedEnum.FOO}.standalone_enum)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n standalone_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.standalone_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n standalone_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_unset", + expr: "has(TestAllTypes{}.single_nested_message)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_other_set", + expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.BAZ}.single_nested_message)", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.BAZ^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_set", + expr: "has(TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{}}.single_nested_message)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_nested_message:TestAllTypes.NestedMessage{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_message~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:cel.expr.conformance.proto3.TestAllTypes.NestedMessage{}~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^cel.expr.conformance.proto3.TestAllTypes.NestedMessage\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_message~test-only~~bool", + type: "bool", + }, + { + original: { + name: "oneof_set_default", + expr: "has(TestAllTypes{single_nested_enum: TestAllTypes.NestedEnum.FOO}.single_nested_enum)", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_nested_enum:TestAllTypes^#*expr.Expr_IdentExpr#.NestedEnum^#*expr.Expr_SelectExpr#.FOO^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_nested_enum~test-only~^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.FOO\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_enum~test-only~~bool", + type: "bool", + }, + ], + }, + { + name: "set_null", + tests: [ + { + original: { + name: "single_message", + expr: "TestAllTypes{single_nested_message: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_nested_message:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_nested_message:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "single_any", + expr: "TestAllTypes{single_any: null}.single_any", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_any:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "single_value", + expr: "TestAllTypes{single_value: null}.single_value", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:null~null\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "single_duration", + expr: "TestAllTypes{single_duration: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_duration:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_duration:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "single_timestamp", + expr: "TestAllTypes{single_timestamp: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_timestamp:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_timestamp:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "single_scalar", + expr: "TestAllTypes{single_bool: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n single_bool:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:25: expected type of field 'single_bool' is 'bool' but provided type is 'null'\n | TestAllTypes{single_bool: null} == TestAllTypes{}\n | ........................^", + }, + { + original: { + name: "repeated", + expr: "TestAllTypes{repeated_int32: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n repeated_int32:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:28: expected type of field 'repeated_int32' is 'list(int)' but provided type is 'null'\n | TestAllTypes{repeated_int32: null} == TestAllTypes{}\n | ...........................^", + }, + { + original: { + name: "map", + expr: "TestAllTypes{map_string_string: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n map_string_string:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:31: expected type of field 'map_string_string' is 'map(string, string)' but provided type is 'null'\n | TestAllTypes{map_string_string: null} == TestAllTypes{}\n | ..............................^", + }, + { + original: { + name: "list_value", + expr: "TestAllTypes{list_value: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n list_value:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:24: expected type of field 'list_value' is 'list(dyn)' but provided type is 'null'\n | TestAllTypes{list_value: null} == TestAllTypes{}\n | .......................^", + }, + { + original: { + name: "single_struct", + expr: "TestAllTypes{single_struct: null} == TestAllTypes{}", + disableCheck: true, + container: "cel.expr.conformance.proto3", + evalError: { errors: [{ message: "unsupported field type" }] }, + }, + ast: "_==_(\n TestAllTypes{\n single_struct:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + error: + "ERROR: \u003cinput\u003e:1:27: expected type of field 'single_struct' is 'map(string, dyn)' but provided type is 'null'\n | TestAllTypes{single_struct: null} == TestAllTypes{}\n | ..........................^", + }, + ], + }, + { + name: "quoted_fields", + tests: [ + { + original: { + name: "set_field", + expr: "TestAllTypes{`in`: true} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: false }, + }, + error: + "ERROR: set_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true} == TestAllTypes{}\n | .............^", + }, + { + original: { + name: "get_field", + expr: "TestAllTypes{`in`: true}.`in`", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + error: + "ERROR: get_field:1:14: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .............^\nERROR: get_field:1:26: unsupported syntax: '`'\n | TestAllTypes{`in`: true}.`in`\n | .........................^", + }, + ], + }, + ], + }, + { + name: "string", + suites: [ + { + name: "size", + tests: [ + { + original: { + name: "empty", + expr: "size('')", + value: { int64Value: "0" }, + }, + ast: 'size(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n ""~string\n)~int^size_string', + type: "int", + }, + { + original: { + name: "one_ascii", + expr: "size('A')", + value: { int64Value: "1" }, + }, + ast: 'size(\n "A"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n "A"~string\n)~int^size_string', + type: "int", + }, + { + original: { + name: "one_unicode", + expr: "size('ÿ')", + value: { int64Value: "1" }, + }, + ast: 'size(\n "ÿ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n "ÿ"~string\n)~int^size_string', + type: "int", + }, + { + original: { + name: "ascii", + expr: "size('four')", + value: { int64Value: "4" }, + }, + ast: 'size(\n "four"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n "four"~string\n)~int^size_string', + type: "int", + }, + { + original: { + name: "unicode", + expr: "size('πέντε')", + value: { int64Value: "5" }, + }, + ast: 'size(\n "πέντε"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n "πέντε"~string\n)~int^size_string', + type: "int", + }, + { + original: { + name: "bytes_empty", + expr: "size(b'')", + value: { int64Value: "0" }, + }, + ast: 'size(\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n b""~bytes\n)~int^size_bytes', + type: "int", + }, + { + original: { + name: "bytes", + expr: "size(b'abc')", + value: { int64Value: "3" }, + }, + ast: 'size(\n b"abc"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'size(\n b"abc"~bytes\n)~int^size_bytes', + type: "int", + }, + ], + }, + { + name: "starts_with", + tests: [ + { + original: { + name: "basic_true", + expr: "'foobar'.startsWith('foo')", + value: { boolValue: true }, + }, + ast: '"foobar"^#*expr.Constant_StringValue#.startsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"foobar"~string.startsWith(\n "foo"~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "basic_false", + expr: "'foobar'.startsWith('bar')", + value: { boolValue: false }, + }, + ast: '"foobar"^#*expr.Constant_StringValue#.startsWith(\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"foobar"~string.startsWith(\n "bar"~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "empty_target", + expr: "''.startsWith('foo')", + value: { boolValue: false }, + }, + ast: '""^#*expr.Constant_StringValue#.startsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.startsWith(\n "foo"~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "empty_arg", + expr: "'foobar'.startsWith('')", + value: { boolValue: true }, + }, + ast: '"foobar"^#*expr.Constant_StringValue#.startsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"foobar"~string.startsWith(\n ""~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "empty_empty", + expr: "''.startsWith('')", + value: { boolValue: true }, + }, + ast: '""^#*expr.Constant_StringValue#.startsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.startsWith(\n ""~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "unicode", + expr: "'завтра'.startsWith('за')", + value: { boolValue: true }, + }, + ast: '"завтра"^#*expr.Constant_StringValue#.startsWith(\n "за"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"завтра"~string.startsWith(\n "за"~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "unicode_smp", + expr: "'🐱😀😛'.startsWith('🐱')", + value: { boolValue: true }, + }, + ast: '"🐱😀😛"^#*expr.Constant_StringValue#.startsWith(\n "🐱"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"🐱😀😛"~string.startsWith(\n "🐱"~string\n)~bool^starts_with_string', + type: "bool", + }, + ], + }, + { + name: "ends_with", + tests: [ + { + original: { + name: "basic_true", + expr: "'foobar'.endsWith('bar')", + value: { boolValue: true }, + }, + ast: '"foobar"^#*expr.Constant_StringValue#.endsWith(\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"foobar"~string.endsWith(\n "bar"~string\n)~bool^ends_with_string', + type: "bool", + }, + { + original: { + name: "basic_false", + expr: "'foobar'.endsWith('foo')", + value: { boolValue: false }, + }, + ast: '"foobar"^#*expr.Constant_StringValue#.endsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"foobar"~string.endsWith(\n "foo"~string\n)~bool^ends_with_string', + type: "bool", + }, + { + original: { + name: "empty_target", + expr: "''.endsWith('foo')", + value: { boolValue: false }, + }, + ast: '""^#*expr.Constant_StringValue#.endsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.endsWith(\n "foo"~string\n)~bool^ends_with_string', + type: "bool", + }, + { + original: { + name: "empty_arg", + expr: "'foobar'.endsWith('')", + value: { boolValue: true }, + }, + ast: '"foobar"^#*expr.Constant_StringValue#.endsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"foobar"~string.endsWith(\n ""~string\n)~bool^ends_with_string', + type: "bool", + }, + { + original: { + name: "empty_empty", + expr: "''.endsWith('')", + value: { boolValue: true }, + }, + ast: '""^#*expr.Constant_StringValue#.endsWith(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.endsWith(\n ""~string\n)~bool^ends_with_string', + type: "bool", + }, + { + original: { + name: "unicode", + expr: "'forté'.endsWith('té')", + value: { boolValue: true }, + }, + ast: '"forté"^#*expr.Constant_StringValue#.endsWith(\n "té"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"forté"~string.endsWith(\n "té"~string\n)~bool^ends_with_string', + type: "bool", + }, + { + original: { + name: "unicode_smp", + expr: "'🐱😀😛'.endsWith('😛')", + value: { boolValue: true }, + }, + ast: '"🐱😀😛"^#*expr.Constant_StringValue#.endsWith(\n "😛"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"🐱😀😛"~string.endsWith(\n "😛"~string\n)~bool^ends_with_string', + type: "bool", + }, + ], + }, + { + name: "matches", + tests: [ + { + original: { + name: "basic", + expr: "'hubba'.matches('ubb')", + value: { boolValue: true }, + }, + ast: '"hubba"^#*expr.Constant_StringValue#.matches(\n "ubb"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"hubba"~string.matches(\n "ubb"~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "empty_target", + expr: "''.matches('foo|bar')", + value: { boolValue: false }, + }, + ast: '""^#*expr.Constant_StringValue#.matches(\n "foo|bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.matches(\n "foo|bar"~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "empty_arg", + expr: "'cows'.matches('')", + value: { boolValue: true }, + }, + ast: '"cows"^#*expr.Constant_StringValue#.matches(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"cows"~string.matches(\n ""~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "empty_empty", + expr: "''.matches('')", + value: { boolValue: true }, + }, + ast: '""^#*expr.Constant_StringValue#.matches(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.matches(\n ""~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "re_concat", + expr: "'abcd'.matches('bc')", + value: { boolValue: true }, + }, + ast: '"abcd"^#*expr.Constant_StringValue#.matches(\n "bc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"abcd"~string.matches(\n "bc"~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "re_alt", + expr: "'grey'.matches('gr(a|e)y')", + value: { boolValue: true }, + }, + ast: '"grey"^#*expr.Constant_StringValue#.matches(\n "gr(a|e)y"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"grey"~string.matches(\n "gr(a|e)y"~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "re_rep", + expr: "'banana'.matches('ba(na)*')", + value: { boolValue: true }, + }, + ast: '"banana"^#*expr.Constant_StringValue#.matches(\n "ba(na)*"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"banana"~string.matches(\n "ba(na)*"~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "unicode", + expr: "'mañana'.matches('a+ñ+a+')", + value: { boolValue: true }, + }, + ast: '"mañana"^#*expr.Constant_StringValue#.matches(\n "a+ñ+a+"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"mañana"~string.matches(\n "a+ñ+a+"~string\n)~bool^matches_string', + type: "bool", + }, + { + original: { + name: "unicode_smp", + expr: "'🐱😀😀'.matches('(a|😀){2}')", + value: { boolValue: true }, + }, + ast: '"🐱😀😀"^#*expr.Constant_StringValue#.matches(\n "(a|😀){2}"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"🐱😀😀"~string.matches(\n "(a|😀){2}"~string\n)~bool^matches_string', + type: "bool", + }, + ], + }, + { + name: "concatenation", + tests: [ + { + original: { + name: "concat_true", + expr: "'he' + 'llo'", + value: { stringValue: "hello" }, + }, + ast: '_+_(\n "he"^#*expr.Constant_StringValue#,\n "llo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n "he"~string,\n "llo"~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "concat_with_spaces", + expr: "'hello' + ' ' == 'hello'", + value: { boolValue: false }, + }, + ast: '_==_(\n _+_(\n "hello"^#*expr.Constant_StringValue#,\n " "^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "hello"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _+_(\n "hello"~string,\n " "~string\n )~string^add_string,\n "hello"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "concat_empty_string_beginning", + expr: "'' + 'abc'", + value: { stringValue: "abc" }, + }, + ast: '_+_(\n ""^#*expr.Constant_StringValue#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n ""~string,\n "abc"~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "concat_empty_string_end", + expr: "'abc' + ''", + value: { stringValue: "abc" }, + }, + ast: '_+_(\n "abc"^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n "abc"~string,\n ""~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "concat_empty_with_empty", + expr: "'' + ''", + value: { stringValue: "" }, + }, + ast: '_+_(\n ""^#*expr.Constant_StringValue#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n ""~string,\n ""~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "unicode_unicode", + expr: "'¢' + 'ÿ' + 'Ȁ'", + value: { stringValue: "¢ÿȀ" }, + }, + ast: '_+_(\n _+_(\n "¢"^#*expr.Constant_StringValue#,\n "ÿ"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "Ȁ"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n _+_(\n "¢"~string,\n "ÿ"~string\n )~string^add_string,\n "Ȁ"~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "ascii_unicode", + expr: "'r' + 'ô' + 'le'", + value: { stringValue: "rôle" }, + }, + ast: '_+_(\n _+_(\n "r"^#*expr.Constant_StringValue#,\n "ô"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "le"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n _+_(\n "r"~string,\n "ô"~string\n )~string^add_string,\n "le"~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "ascii_unicode_unicode_smp", + expr: "'a' + 'ÿ' + '🐱'", + value: { stringValue: "aÿ🐱" }, + }, + ast: '_+_(\n _+_(\n "a"^#*expr.Constant_StringValue#,\n "ÿ"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "🐱"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n _+_(\n "a"~string,\n "ÿ"~string\n )~string^add_string,\n "🐱"~string\n)~string^add_string', + type: "string", + }, + { + original: { + name: "empty_unicode", + expr: "'' + 'Ω' + ''", + value: { stringValue: "Ω" }, + }, + ast: '_+_(\n _+_(\n ""^#*expr.Constant_StringValue#,\n "Ω"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n _+_(\n ""~string,\n "Ω"~string\n )~string^add_string,\n ""~string\n)~string^add_string', + type: "string", + }, + ], + }, + { + name: "contains", + tests: [ + { + original: { + name: "contains_true", + expr: "'hello'.contains('he')", + value: { boolValue: true }, + }, + ast: '"hello"^#*expr.Constant_StringValue#.contains(\n "he"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"hello"~string.contains(\n "he"~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "contains_empty", + expr: "'hello'.contains('')", + value: { boolValue: true }, + }, + ast: '"hello"^#*expr.Constant_StringValue#.contains(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"hello"~string.contains(\n ""~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "contains_false", + expr: "'hello'.contains('ol')", + value: { boolValue: false }, + }, + ast: '"hello"^#*expr.Constant_StringValue#.contains(\n "ol"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"hello"~string.contains(\n "ol"~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "contains_multiple", + expr: "'abababc'.contains('ababc')", + value: { boolValue: true }, + }, + ast: '"abababc"^#*expr.Constant_StringValue#.contains(\n "ababc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"abababc"~string.contains(\n "ababc"~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "contains_unicode", + expr: "'Straße'.contains('aß')", + value: { boolValue: true }, + }, + ast: '"Straße"^#*expr.Constant_StringValue#.contains(\n "aß"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"Straße"~string.contains(\n "aß"~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "contains_unicode_smp", + expr: "'🐱😀😁'.contains('😀')", + value: { boolValue: true }, + }, + ast: '"🐱😀😁"^#*expr.Constant_StringValue#.contains(\n "😀"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"🐱😀😁"~string.contains(\n "😀"~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "empty_contains", + expr: "''.contains('something')", + value: { boolValue: false }, + }, + ast: '""^#*expr.Constant_StringValue#.contains(\n "something"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.contains(\n "something"~string\n)~bool^contains_string', + type: "bool", + }, + { + original: { + name: "empty_empty", + expr: "''.contains('')", + value: { boolValue: true }, + }, + ast: '""^#*expr.Constant_StringValue#.contains(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '""~string.contains(\n ""~string\n)~bool^contains_string', + type: "bool", + }, + ], + }, + { + name: "bytes_concat", + tests: [ + { + original: { + name: "concat", + expr: "b'abc' + b'def'", + value: { bytesValue: "YWJjZGVm" }, + }, + ast: '_+_(\n b"abc"^#*expr.Constant_BytesValue#,\n b"def"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n b"abc"~bytes,\n b"def"~bytes\n)~bytes^add_bytes', + type: "bytes", + }, + { + original: { + name: "left_unit", + expr: "b'' + b'\\xffoo'", + value: { bytesValue: "/29v" }, + }, + ast: '_+_(\n b""^#*expr.Constant_BytesValue#,\n b"\\xffoo"^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n b""~bytes,\n b"\\xffoo"~bytes\n)~bytes^add_bytes', + type: "bytes", + }, + { + original: { + name: "right_unit", + expr: "b'zxy' + b''", + value: { bytesValue: "enh5" }, + }, + ast: '_+_(\n b"zxy"^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n b"zxy"~bytes,\n b""~bytes\n)~bytes^add_bytes', + type: "bytes", + }, + { + original: { + name: "empty_empty", + expr: "b'' + b''", + value: { bytesValue: "" }, + }, + ast: '_+_(\n b""^#*expr.Constant_BytesValue#,\n b""^#*expr.Constant_BytesValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: '_+_(\n b""~bytes,\n b""~bytes\n)~bytes^add_bytes', + type: "bytes", + }, + ], + }, + ], + }, + { + name: "string_ext", + suites: [ + { + name: "char_at", + tests: [ + { + original: { + name: "middle_index", + expr: "'tacocat'.charAt(3)", + value: { stringValue: "o" }, + }, + ast: '"tacocat"^#*expr.Constant_StringValue#.charAt(\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"tacocat"~string.charAt(\n 3~int\n)~string^string_char_at_int', + type: "string", + }, + { + original: { + name: "end_index", + expr: "'tacocat'.charAt(7)", + value: { stringValue: "" }, + }, + ast: '"tacocat"^#*expr.Constant_StringValue#.charAt(\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"tacocat"~string.charAt(\n 7~int\n)~string^string_char_at_int', + type: "string", + }, + { + original: { + name: "multiple", + expr: "'©αT'.charAt(0) == '©' \u0026\u0026 '©αT'.charAt(1) == 'α' \u0026\u0026 '©αT'.charAt(2) == 'T'", + }, + ast: '_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n "©αT"^#*expr.Constant_StringValue#.charAt(\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "©"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n _==_(\n "©αT"^#*expr.Constant_StringValue#.charAt(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "α"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n _==_(\n "©αT"^#*expr.Constant_StringValue#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "T"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u0026\u0026_(\n _\u0026\u0026_(\n _==_(\n "©αT"~string.charAt(\n 0~int\n )~string^string_char_at_int,\n "©"~string\n )~bool^equals,\n _==_(\n "©αT"~string.charAt(\n 1~int\n )~string^string_char_at_int,\n "α"~string\n )~bool^equals\n )~bool^logical_and,\n _==_(\n "©αT"~string.charAt(\n 2~int\n )~string^string_char_at_int,\n "T"~string\n )~bool^equals\n)~bool^logical_and', + type: "bool", + }, + ], + }, + { + name: "index_of", + tests: [ + { + original: { + name: "empty_index", + expr: "'tacocat'.indexOf('')", + value: { int64Value: "0" }, + }, + ast: '"tacocat"^#*expr.Constant_StringValue#.indexOf(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"tacocat"~string.indexOf(\n ""~string\n)~int^string_index_of_string', + type: "int", + }, + { + original: { + name: "string_index", + expr: "'tacocat'.indexOf('ac')", + value: { int64Value: "1" }, + }, + ast: '"tacocat"^#*expr.Constant_StringValue#.indexOf(\n "ac"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"tacocat"~string.indexOf(\n "ac"~string\n)~int^string_index_of_string', + type: "int", + }, + { + original: { + name: "nomatch", + expr: "'tacocat'.indexOf('none') == -1", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "none"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.indexOf(\n "none"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "empty_index", + expr: "'tacocat'.indexOf('', 3) == 3", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n ""^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.indexOf(\n ""~string,\n 3~int\n )~int^string_index_of_string_int,\n 3~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "char_index", + expr: "'tacocat'.indexOf('a', 3) == 5", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "a"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.indexOf(\n "a"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_index", + expr: "'tacocat'.indexOf('at', 3) == 5", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "at"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.indexOf(\n "at"~string,\n 3~int\n )~int^string_index_of_string_int,\n 5~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_char", + expr: "'ta©o©αT'.indexOf('©') == 2", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.indexOf(\n "©"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_char_index", + expr: "'ta©o©αT'.indexOf('©', 3) == 4", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.indexOf(\n "©"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_string_index", + expr: "'ta©o©αT'.indexOf('©αT', 3) == 4", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©αT"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.indexOf(\n "©αT"~string,\n 3~int\n )~int^string_index_of_string_int,\n 4~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_string_nomatch_index", + expr: "'ta©o©αT'.indexOf('©α', 5) == -1", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.indexOf(\n "©α"^#*expr.Constant_StringValue#,\n 5^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.indexOf(\n "©α"~string,\n 5~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { name: "char_index", expr: "'ijk'.indexOf('k') == 2" }, + ast: '_==_(\n "ijk"^#*expr.Constant_StringValue#.indexOf(\n "k"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ijk"~string.indexOf(\n "k"~string\n )~int^string_index_of_string,\n 2~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_with_space_fullmatch", + expr: "'hello wello'.indexOf('hello wello') == 0", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.indexOf(\n "hello wello"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.indexOf(\n "hello wello"~string\n )~int^string_index_of_string,\n 0~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_with_space_index", + expr: "'hello wello'.indexOf('ello', 6) == 7", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.indexOf(\n "ello"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.indexOf(\n "ello"~string,\n 6~int\n )~int^string_index_of_string_int,\n 7~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_nomatch_index", + expr: "'hello wello'.indexOf('elbo room!!') == -1", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.indexOf(\n "elbo room!!"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.indexOf(\n "elbo room!!"~string\n )~int^string_index_of_string,\n -1~int\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "last_index_of", + tests: [ + { + original: { + name: "empty_string", + expr: "''.lastIndexOf('@@') == -1", + }, + ast: '_==_(\n ""^#*expr.Constant_StringValue#.lastIndexOf(\n "@@"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n ""~string.lastIndexOf(\n "@@"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "empty_argument", + expr: "'tacocat'.lastIndexOf('') == 7", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 7^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n ""~string\n )~int^string_last_index_of_string,\n 7~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string", + expr: "'tacocat'.lastIndexOf('at') == 5", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "at"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 5^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n "at"~string\n )~int^string_last_index_of_string,\n 5~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_nomatch", + expr: "'tacocat'.lastIndexOf('none') == -1", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "none"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n "none"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "empty_index", + expr: "'tacocat'.lastIndexOf('', 3) == 3", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n ""^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n ""~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 3~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "char_index", + expr: "'tacocat'.lastIndexOf('a', 3) == 1", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "a"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n "a"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_char", + expr: "'ta©o©αT'.lastIndexOf('©') == 4", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.lastIndexOf(\n "©"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.lastIndexOf(\n "©"~string\n )~int^string_last_index_of_string,\n 4~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_char_index", + expr: "'ta©o©αT'.lastIndexOf('©', 3) == 2", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.lastIndexOf(\n "©"^#*expr.Constant_StringValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.lastIndexOf(\n "©"~string,\n 3~int\n )~int^string_last_index_of_string_int,\n 2~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_string_index", + expr: "'ta©o©αT'.lastIndexOf('©α', 4) == 4", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.lastIndexOf(\n "©α"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 4^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.lastIndexOf(\n "©α"~string,\n 4~int\n )~int^string_last_index_of_string_int,\n 4~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_with_space_string_index", + expr: "'hello wello'.lastIndexOf('ello', 6) == 1", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "ello"^#*expr.Constant_StringValue#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.lastIndexOf(\n "ello"~string,\n 6~int\n )~int^string_last_index_of_string_int,\n 1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_with_space_string_nomatch", + expr: "'hello wello'.lastIndexOf('low') == -1", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "low"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.lastIndexOf(\n "low"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_with_space_string_with_space_nomatch", + expr: "'hello wello'.lastIndexOf('elbo room!!') == -1", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "elbo room!!"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.lastIndexOf(\n "elbo room!!"~string\n )~int^string_last_index_of_string,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "string_with_space_fullmatch", + expr: "'hello wello'.lastIndexOf('hello wello') == 0", + }, + ast: '_==_(\n "hello wello"^#*expr.Constant_StringValue#.lastIndexOf(\n "hello wello"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello wello"~string.lastIndexOf(\n "hello wello"~string\n )~int^string_last_index_of_string,\n 0~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "repeated_string", + expr: "'bananananana'.lastIndexOf('nana', 7) == 6", + }, + ast: '_==_(\n "bananananana"^#*expr.Constant_StringValue#.lastIndexOf(\n "nana"^#*expr.Constant_StringValue#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 6^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "bananananana"~string.lastIndexOf(\n "nana"~string,\n 7~int\n )~int^string_last_index_of_string_int,\n 6~int\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "ascii_casing", + tests: [ + { + original: { + name: "lowerascii", + expr: "'TacoCat'.lowerAscii() == 'tacocat'", + }, + ast: '_==_(\n "TacoCat"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n "tacocat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "TacoCat"~string.lowerAscii()~string^string_lower_ascii,\n "tacocat"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "lowerascii_unicode", + expr: "'TacoCÆt'.lowerAscii() == 'tacocÆt'", + }, + ast: '_==_(\n "TacoCÆt"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n "tacocÆt"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "TacoCÆt"~string.lowerAscii()~string^string_lower_ascii,\n "tacocÆt"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "lowerascii_unicode_with_space", + expr: "'TacoCÆt Xii'.lowerAscii() == 'tacocÆt xii'", + }, + ast: '_==_(\n "TacoCÆt Xii"^#*expr.Constant_StringValue#.lowerAscii()^#*expr.Expr_CallExpr#,\n "tacocÆt xii"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "TacoCÆt Xii"~string.lowerAscii()~string^string_lower_ascii,\n "tacocÆt xii"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "upperascii", + expr: "'tacoCat'.upperAscii() == 'TACOCAT'", + }, + ast: '_==_(\n "tacoCat"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n "TACOCAT"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacoCat"~string.upperAscii()~string^string_upper_ascii,\n "TACOCAT"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "upperascii_unicode", + expr: "'tacoCαt'.upperAscii() == 'TACOCαT'", + }, + ast: '_==_(\n "tacoCαt"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n "TACOCαT"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacoCαt"~string.upperAscii()~string^string_upper_ascii,\n "TACOCαT"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "upperascii_unicode_with_space", + expr: "'TacoCÆt Xii'.upperAscii() == 'TACOCÆT XII'", + }, + ast: '_==_(\n "TacoCÆt Xii"^#*expr.Constant_StringValue#.upperAscii()^#*expr.Expr_CallExpr#,\n "TACOCÆT XII"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "TacoCÆt Xii"~string.upperAscii()~string^string_upper_ascii,\n "TACOCÆT XII"~string\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "replace", + tests: [ + { + original: { + name: "no_placeholder", + expr: "'12 days 12 hours'.replace('{0}', '2') == '12 days 12 hours'", + }, + ast: '_==_(\n "12 days 12 hours"^#*expr.Constant_StringValue#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "12 days 12 hours"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "12 days 12 hours"~string.replace(\n "{0}"~string,\n "2"~string\n )~string^string_replace_string_string,\n "12 days 12 hours"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "basic", + expr: "'{0} days {0} hours'.replace('{0}', '2') == '2 days 2 hours'", + }, + ast: '_==_(\n "{0} days {0} hours"^#*expr.Constant_StringValue#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "2 days 2 hours"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "{0} days {0} hours"~string.replace(\n "{0}"~string,\n "2"~string\n )~string^string_replace_string_string,\n "2 days 2 hours"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "chained", + expr: "'{0} days {0} hours'.replace('{0}', '2', 1).replace('{0}', '23') == '2 days 23 hours'", + }, + ast: '_==_(\n "{0} days {0} hours"^#*expr.Constant_StringValue#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#.replace(\n "{0}"^#*expr.Constant_StringValue#,\n "23"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "2 days 23 hours"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "{0} days {0} hours"~string.replace(\n "{0}"~string,\n "2"~string,\n 1~int\n )~string^string_replace_string_string_int.replace(\n "{0}"~string,\n "23"~string\n )~string^string_replace_string_string,\n "2 days 23 hours"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode", + expr: "'1 ©αT taco'.replace('αT', 'o©α') == '1 ©o©α taco'", + }, + ast: '_==_(\n "1 ©αT taco"^#*expr.Constant_StringValue#.replace(\n "αT"^#*expr.Constant_StringValue#,\n "o©α"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "1 ©o©α taco"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "1 ©αT taco"~string.replace(\n "αT"~string,\n "o©α"~string\n )~string^string_replace_string_string,\n "1 ©o©α taco"~string\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "split", + tests: [ + { + original: { + name: "empty", + expr: "'hello world'.split(' ') == ['hello', 'world']", + }, + ast: '_==_(\n "hello world"^#*expr.Constant_StringValue#.split(\n " "^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "hello"^#*expr.Constant_StringValue#,\n "world"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello world"~string.split(\n " "~string\n )~list(string)^string_split_string,\n [\n "hello"~string,\n "world"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "zero_limit", + expr: "'hello world events!'.split(' ', 0) == []", + }, + ast: '_==_(\n "hello world events!"^#*expr.Constant_StringValue#.split(\n " "^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello world events!"~string.split(\n " "~string,\n 0~int\n )~list(string)^string_split_string_int,\n []~list(string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "one_limit", + expr: "'hello world events!'.split(' ', 1) == ['hello world events!']", + }, + ast: '_==_(\n "hello world events!"^#*expr.Constant_StringValue#.split(\n " "^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "hello world events!"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "hello world events!"~string.split(\n " "~string,\n 1~int\n )~list(string)^string_split_string_int,\n [\n "hello world events!"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_negative_limit", + expr: "'o©o©o©o'.split('©', -1) == ['o', 'o', 'o', 'o']", + }, + ast: '_==_(\n "o©o©o©o"^#*expr.Constant_StringValue#.split(\n "©"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "o"^#*expr.Constant_StringValue#,\n "o"^#*expr.Constant_StringValue#,\n "o"^#*expr.Constant_StringValue#,\n "o"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "o©o©o©o"~string.split(\n "©"~string,\n -1~int\n )~list(string)^string_split_string_int,\n [\n "o"~string,\n "o"~string,\n "o"~string,\n "o"~string\n ]~list(string)\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "substring", + tests: [ + { + original: { + name: "start", + expr: "'tacocat'.substring(4) == 'cat'", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 4~int\n )~string^string_substring_int,\n "cat"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "start_with_max_length", + expr: "'tacocat'.substring(7) == ''", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 7~int\n )~string^string_substring_int,\n ""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "start_and_end", + expr: "'tacocat'.substring(0, 4) == 'taco'", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "taco"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 0~int,\n 4~int\n )~string^string_substring_int_int,\n "taco"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "start_and_end_equal_value", + expr: "'tacocat'.substring(4, 4) == ''", + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 4^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 4~int,\n 4~int\n )~string^string_substring_int_int,\n ""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_start_and_end", + expr: "'ta©o©αT'.substring(2, 6) == '©o©α'", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.substring(\n 2^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "©o©α"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.substring(\n 2~int,\n 6~int\n )~string^string_substring_int_int,\n "©o©α"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_start_and_end_equal_value", + expr: "'ta©o©αT'.substring(7, 7) == ''", + }, + ast: '_==_(\n "ta©o©αT"^#*expr.Constant_StringValue#.substring(\n 7^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "ta©o©αT"~string.substring(\n 7~int,\n 7~int\n )~string^string_substring_int_int,\n ""~string\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "trim", + tests: [ + { + original: { + name: "blank_spaces_escaped_chars", + expr: "' \\f\\n\\r\\t\\vtext '.trim() == 'text'", + }, + ast: '_==_(\n " \\f\\n\\r\\t\\vtext "^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n " \\f\\n\\r\\t\\vtext "~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_space_chars_1", + expr: "'\\u0085\\u00a0\\u1680text'.trim() == 'text'", + }, + ast: '_==_(\n "\\u0085\\u00a0\\u1680text"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "\\u0085\\u00a0\\u1680text"~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_space_chars_2", + expr: "'text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009'.trim() == 'text'", + }, + ast: '_==_(\n "text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "text\\u2000\\u2001\\u2002\\u2003\\u2004\\u2004\\u2006\\u2007\\u2008\\u2009"~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_space_chars_3", + expr: "'\\u200atext\\u2028\\u2029\\u202F\\u205F\\u3000'.trim() == 'text'", + }, + ast: '_==_(\n "\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "text"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "\\u200atext\\u2028\\u2029\\u202f\\u205f\\u3000"~string.trim()~string^string_trim,\n "text"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_no_trim", + expr: "'\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'.trim() == '\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff'", + }, + ast: '_==_(\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"^#*expr.Constant_StringValue#.trim()^#*expr.Expr_CallExpr#,\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"~string.trim()~string^string_trim,\n "\\u180etext\\u200b\\u200c\\u200d\\u2060\\ufeff"~string\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "join", + tests: [ + { + original: { + name: "empty_separator", + expr: "['x', 'y'].join() == 'xy'", + }, + ast: '_==_(\n [\n "x"^#*expr.Constant_StringValue#,\n "y"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n "xy"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n [\n "x"~string,\n "y"~string\n ]~list(string).join()~string^list_join,\n "xy"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "dash_separator", + expr: "['x', 'y'].join('-') == 'x-y'", + }, + ast: '_==_(\n [\n "x"^#*expr.Constant_StringValue#,\n "y"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#.join(\n "-"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "x-y"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n [\n "x"~string,\n "y"~string\n ]~list(string).join(\n "-"~string\n )~string^list_join_string,\n "x-y"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "empty_string_empty_separator", + expr: "[].join() == ''", + }, + ast: '_==_(\n []^#*expr.Expr_ListExpr#.join()^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n []~list(string).join()~string^list_join,\n ""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "empty_string_dash_separator", + expr: "[].join('-') == ''", + }, + ast: '_==_(\n []^#*expr.Expr_ListExpr#.join(\n "-"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n []~list(string).join(\n "-"~string\n )~string^list_join_string,\n ""~string\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "quote", + tests: [ + { + original: { + name: "multiline", + expr: 'strings.quote("first\\nsecond") == "\\"first\\\\nsecond\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "first\\nsecond"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"first\\\\nsecond\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "first\\nsecond"~string\n )~string^strings_quote,\n "\\"first\\\\nsecond\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "escaped", + expr: 'strings.quote("bell\\a") == "\\"bell\\\\a\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "bell\\a"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"bell\\\\a\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "bell\\a"~string\n )~string^strings_quote,\n "\\"bell\\\\a\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "backspace", + expr: 'strings.quote("\\bbackspace") == "\\"\\\\bbackspace\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "\\bbackspace"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"\\\\bbackspace\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "\\bbackspace"~string\n )~string^strings_quote,\n "\\"\\\\bbackspace\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "form_feed", + expr: 'strings.quote("\\fform feed") == "\\"\\\\fform feed\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "\\fform feed"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"\\\\fform feed\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "\\fform feed"~string\n )~string^strings_quote,\n "\\"\\\\fform feed\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "carriage_return", + expr: 'strings.quote("carriage \\r return") == "\\"carriage \\\\r return\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "carriage \\r return"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"carriage \\\\r return\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "carriage \\r return"~string\n )~string^strings_quote,\n "\\"carriage \\\\r return\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "horizontal_tab", + expr: 'strings.quote("horizontal tab\\t") == "\\"horizontal tab\\\\t\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "horizontal tab\\t"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"horizontal tab\\\\t\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "horizontal tab\\t"~string\n )~string^strings_quote,\n "\\"horizontal tab\\\\t\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "vertical_tab", + expr: 'strings.quote("vertical \\v tab") == "\\"vertical \\\\v tab\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "vertical \\v tab"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"vertical \\\\v tab\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "vertical \\v tab"~string\n )~string^strings_quote,\n "\\"vertical \\\\v tab\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "double_slash", + expr: 'strings.quote("double \\\\\\\\ slash") == "\\"double \\\\\\\\\\\\\\\\ slash\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "double \\\\\\\\ slash"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"double \\\\\\\\\\\\\\\\ slash\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "double \\\\\\\\ slash"~string\n )~string^strings_quote,\n "\\"double \\\\\\\\\\\\\\\\ slash\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "two_escape_sequences", + expr: 'strings.quote("two escape sequences \\\\a\\\\n") == "\\"two escape sequences \\\\\\\\a\\\\\\\\n\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "two escape sequences \\\\a\\\\n"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"two escape sequences \\\\\\\\a\\\\\\\\n\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "two escape sequences \\\\a\\\\n"~string\n )~string^strings_quote,\n "\\"two escape sequences \\\\\\\\a\\\\\\\\n\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "verbatim", + expr: 'strings.quote("verbatim") == "\\"verbatim\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "verbatim"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"verbatim\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "verbatim"~string\n )~string^strings_quote,\n "\\"verbatim\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "ends_with", + expr: 'strings.quote("ends with \\\\") == "\\"ends with \\\\\\\\\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "ends with \\\\"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"ends with \\\\\\\\\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "ends with \\\\"~string\n )~string^strings_quote,\n "\\"ends with \\\\\\\\\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "starts_with", + expr: 'strings.quote("\\\\ starts with") == "\\"\\\\\\\\ starts with\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "\\\\ starts with"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"\\\\\\\\ starts with\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "\\\\ starts with"~string\n )~string^strings_quote,\n "\\"\\\\\\\\ starts with\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "printable_unicode", + expr: 'strings.quote("printable unicode😀") == "\\"printable unicode😀\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "printable unicode😀"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"printable unicode😀\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "printable unicode😀"~string\n )~string^strings_quote,\n "\\"printable unicode😀\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "mid_string_quote", + expr: 'strings.quote("mid string \\" quote") == "\\"mid string \\\\\\" quote\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "mid string \\" quote"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"mid string \\\\\\" quote\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "mid string \\" quote"~string\n )~string^strings_quote,\n "\\"mid string \\\\\\" quote\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "single_quote_with_double_quote", + expr: 'strings.quote(\'single-quote with "double quote"\') == "\\"single-quote with \\\\\\"double quote\\\\\\"\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "single-quote with \\"double quote\\""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"single-quote with \\\\\\"double quote\\\\\\"\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "single-quote with \\"double quote\\""~string\n )~string^strings_quote,\n "\\"single-quote with \\\\\\"double quote\\\\\\"\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "size_unicode_char", + expr: 'strings.quote("size(\'ÿ\')") == "\\"size(\'ÿ\')\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "size(\'ÿ\')"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"size(\'ÿ\')\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "size(\'ÿ\')"~string\n )~string^strings_quote,\n "\\"size(\'ÿ\')\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "size_unicode_string", + expr: 'strings.quote("size(\'πέντε\')") == "\\"size(\'πέντε\')\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "size(\'πέντε\')"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"size(\'πέντε\')\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "size(\'πέντε\')"~string\n )~string^strings_quote,\n "\\"size(\'πέντε\')\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode", + expr: 'strings.quote("завтра") == "\\"завтра\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "завтра"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"завтра\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "завтра"~string\n )~string^strings_quote,\n "\\"завтра\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "unicode_code_points", + expr: 'strings.quote("\\U0001F431\\U0001F600\\U0001F61B")', + value: { stringValue: '"🐱😀😛"' }, + }, + ast: 'strings^#*expr.Expr_IdentExpr#.quote(\n "🐱😀😛"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'strings.quote(\n "🐱😀😛"~string\n)~string^strings_quote', + type: "string", + }, + { + original: { + name: "unicode_2", + expr: 'strings.quote("ta©o©αT") == "\\"ta©o©αT\\""', + }, + ast: '_==_(\n strings^#*expr.Expr_IdentExpr#.quote(\n "ta©o©αT"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "\\"ta©o©αT\\""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n strings.quote(\n "ta©o©αT"~string\n )~string^strings_quote,\n "\\"ta©o©αT\\""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "empty_quote", + expr: 'strings.quote("")', + value: { stringValue: '""' }, + }, + ast: 'strings^#*expr.Expr_IdentExpr#.quote(\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: 'strings.quote(\n ""~string\n)~string^strings_quote', + type: "string", + }, + ], + }, + { + name: "format", + tests: [ + { + original: { + name: "no-op", + expr: '"no substitution".format([])', + value: { stringValue: "no substitution" }, + }, + ast: '"no substitution"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"no substitution"~string.format(\n []~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "mid-string substitution", + expr: '"str is %s and some more".format(["filler"])', + value: { stringValue: "str is filler and some more" }, + }, + ast: '"str is %s and some more"^#*expr.Constant_StringValue#.format(\n [\n "filler"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"str is %s and some more"~string.format(\n [\n "filler"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "percent escaping", + expr: '"%% and also %%".format([])', + value: { stringValue: "% and also %" }, + }, + ast: '"%% and also %%"^#*expr.Constant_StringValue#.format(\n []^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%% and also %%"~string.format(\n []~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "substitution inside escaped percent signs", + expr: '"%%%s%%".format(["text"])', + value: { stringValue: "%text%" }, + }, + ast: '"%%%s%%"^#*expr.Constant_StringValue#.format(\n [\n "text"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%%%s%%"~string.format(\n [\n "text"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "substitution with one escaped percent sign on the right", + expr: '"%s%%".format(["percent on the right"])', + value: { stringValue: "percent on the right%" }, + }, + ast: '"%s%%"^#*expr.Constant_StringValue#.format(\n [\n "percent on the right"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s%%"~string.format(\n [\n "percent on the right"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "substitution with one escaped percent sign on the left", + expr: '"%%%s".format(["percent on the left"])', + value: { stringValue: "%percent on the left" }, + }, + ast: '"%%%s"^#*expr.Constant_StringValue#.format(\n [\n "percent on the left"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%%%s"~string.format(\n [\n "percent on the left"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "multiple substitutions", + expr: '"%d %d %d, %s %s %s, %d %d %d, %s %s %s".format([1, 2, 3, "A", "B", "C", 4, 5, 6, "D", "E", "F"])', + value: { stringValue: "1 2 3, A B C, 4 5 6, D E F" }, + }, + ast: '"%d %d %d, %s %s %s, %d %d %d, %s %s %s"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n "A"^#*expr.Constant_StringValue#,\n "B"^#*expr.Constant_StringValue#,\n "C"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n "D"^#*expr.Constant_StringValue#,\n "E"^#*expr.Constant_StringValue#,\n "F"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d %d %d, %s %s %s, %d %d %d, %s %s %s"~string.format(\n [\n 1~int,\n 2~int,\n 3~int,\n "A"~string,\n "B"~string,\n "C"~string,\n 4~int,\n 5~int,\n 6~int,\n "D"~string,\n "E"~string,\n "F"~string\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "percent sign escape sequence support", + expr: '"%%escaped %s%%".format(["percent"])', + value: { stringValue: "%escaped percent%" }, + }, + ast: '"%%escaped %s%%"^#*expr.Constant_StringValue#.format(\n [\n "percent"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%%escaped %s%%"~string.format(\n [\n "percent"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "fixed point formatting clause", + expr: '"%.3f".format([1.2345])', + value: { stringValue: "1.234" }, + }, + ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.3f"~string.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "binary formatting clause", + expr: '"this is 5 in binary: %b".format([5])', + value: { stringValue: "this is 5 in binary: 101" }, + }, + ast: '"this is 5 in binary: %b"^#*expr.Constant_StringValue#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"this is 5 in binary: %b"~string.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "uint support for binary formatting", + expr: '"unsigned 64 in binary: %b".format([uint(64)])', + value: { stringValue: "unsigned 64 in binary: 1000000" }, + }, + ast: '"unsigned 64 in binary: %b"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"unsigned 64 in binary: %b"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "bool support for binary formatting", + expr: '"bit set from bool: %b".format([true])', + value: { stringValue: "bit set from bool: 1" }, + }, + ast: '"bit set from bool: %b"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"bit set from bool: %b"~string.format(\n [\n true~bool\n ]~list(bool)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "octal formatting clause", + expr: '"%o".format([11])', + value: { stringValue: "13" }, + }, + ast: '"%o"^#*expr.Constant_StringValue#.format(\n [\n 11^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%o"~string.format(\n [\n 11~int\n ]~list(int)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "uint support for octal formatting clause", + expr: '"this is an unsigned octal: %o".format([uint(65535)])', + value: { stringValue: "this is an unsigned octal: 177777" }, + }, + ast: '"this is an unsigned octal: %o"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 65535^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"this is an unsigned octal: %o"~string.format(\n [\n uint(\n 65535~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "lowercase hexadecimal formatting clause", + expr: '"%x is 20 in hexadecimal".format([30])', + value: { stringValue: "1e is 20 in hexadecimal" }, + }, + ast: '"%x is 20 in hexadecimal"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%x is 20 in hexadecimal"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "uppercase hexadecimal formatting clause", + expr: '"%X is 20 in hexadecimal".format([30])', + value: { stringValue: "1E is 20 in hexadecimal" }, + }, + ast: '"%X is 20 in hexadecimal"^#*expr.Constant_StringValue#.format(\n [\n 30^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%X is 20 in hexadecimal"~string.format(\n [\n 30~int\n ]~list(int)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "unsigned support for hexadecimal formatting clause", + expr: '"%X is 6000 in hexadecimal".format([uint(6000)])', + value: { stringValue: "1770 is 6000 in hexadecimal" }, + }, + ast: '"%X is 6000 in hexadecimal"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 6000^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%X is 6000 in hexadecimal"~string.format(\n [\n uint(\n 6000~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "string support with hexadecimal formatting clause", + expr: '"%x".format(["Hello world!"])', + value: { stringValue: "48656c6c6f20776f726c6421" }, + }, + ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n "Hello world!"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%x"~string.format(\n [\n "Hello world!"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "string support with uppercase hexadecimal formatting clause", + expr: '"%X".format(["Hello world!"])', + value: { stringValue: "48656C6C6F20776F726C6421" }, + }, + ast: '"%X"^#*expr.Constant_StringValue#.format(\n [\n "Hello world!"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%X"~string.format(\n [\n "Hello world!"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "byte support with hexadecimal formatting clause", + expr: '"%x".format([b"byte string"])', + value: { stringValue: "6279746520737472696e67" }, + }, + ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n b"byte string"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%x"~string.format(\n [\n b"byte string"~bytes\n ]~list(bytes)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "byte support with uppercase hexadecimal formatting clause", + expr: '"%X".format([b"byte string"])', + value: { stringValue: "6279746520737472696E67" }, + }, + ast: '"%X"^#*expr.Constant_StringValue#.format(\n [\n b"byte string"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%X"~string.format(\n [\n b"byte string"~bytes\n ]~list(bytes)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "scientific notation formatting clause", + expr: '"%.6e".format([1052.032911275])', + value: { stringValue: "1.052033e+03" }, + }, + ast: '"%.6e"^#*expr.Constant_StringValue#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.6e"~string.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "default precision for fixed-point clause", + expr: '"%f".format([2.71828])', + value: { stringValue: "2.718280" }, + }, + ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%f"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "default precision for scientific notation", + expr: '"%e".format([2.71828])', + value: { stringValue: "2.718280e+00" }, + }, + ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%e"~string.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "NaN support for scientific notation", + expr: '"%e".format([double("NaN")])', + value: { stringValue: "NaN" }, + }, + ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%e"~string.format(\n [\n double(\n "NaN"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "positive infinity support for scientific notation", + expr: '"%e".format([double("Infinity")])', + value: { stringValue: "Infinity" }, + }, + ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%e"~string.format(\n [\n double(\n "Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "negative infinity support for scientific notation", + expr: '"%e".format([double("-Infinity")])', + value: { stringValue: "-Infinity" }, + }, + ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%e"~string.format(\n [\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "NaN support for decimal", + expr: '"%d".format([double("NaN")])', + value: { stringValue: "NaN" }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d"~string.format(\n [\n double(\n "NaN"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "positive infinity support for decimal", + expr: '"%d".format([double("Infinity")])', + value: { stringValue: "Infinity" }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d"~string.format(\n [\n double(\n "Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "negative infinity support for decimal", + expr: '"%d".format([double("-Infinity")])', + value: { stringValue: "-Infinity" }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d"~string.format(\n [\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "NaN support for fixed-point", + expr: '"%f".format([double("NaN")])', + value: { stringValue: "NaN" }, + }, + ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%f"~string.format(\n [\n double(\n "NaN"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "positive infinity support for fixed-point", + expr: '"%f".format([double("Infinity")])', + value: { stringValue: "Infinity" }, + }, + ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%f"~string.format(\n [\n double(\n "Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "negative infinity support for fixed-point", + expr: '"%f".format([double("-Infinity")])', + value: { stringValue: "-Infinity" }, + }, + ast: '"%f"^#*expr.Constant_StringValue#.format(\n [\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%f"~string.format(\n [\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "uint support for decimal clause", + expr: '"%d".format([uint(64)])', + value: { stringValue: "64" }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n uint(\n 64^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d"~string.format(\n [\n uint(\n 64~int\n )~uint^int64_to_uint64\n ]~list(uint)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "null support for string", + expr: '"%s".format([null])', + value: { stringValue: "null" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n null~null\n ]~list(null)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "int support for string", + expr: '"%s".format([999999999999])', + value: { stringValue: "999999999999" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n 999999999999^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n 999999999999~int\n ]~list(int)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "bytes support for string", + expr: '"%s".format([b"xyz"])', + value: { stringValue: "xyz" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n b"xyz"^#*expr.Constant_BytesValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n b"xyz"~bytes\n ]~list(bytes)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "type() support for string", + expr: '"%s".format([type("test string")])', + value: { stringValue: "string" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n type(\n "test string"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n type(\n "test string"~string\n )~type(string)^type\n ]~list(type(string))\n)~string^string_format', + type: "string", + }, + { + original: { + name: "timestamp support for string", + expr: '"%s".format([timestamp("2023-02-03T23:31:20+00:00")])', + value: { stringValue: "2023-02-03T23:31:20Z" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n timestamp(\n "2023-02-03T23:31:20+00:00"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n timestamp(\n "2023-02-03T23:31:20+00:00"~string\n )~timestamp^string_to_timestamp\n ]~list(timestamp)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "duration support for string", + expr: '"%s".format([duration("1h45m47s")])', + value: { stringValue: "6347s" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n duration(\n "1h45m47s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n duration(\n "1h45m47s"~string\n )~duration^string_to_duration\n ]~list(duration)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "list support for string", + expr: '"%s".format([["abc", 3.14, null, [9, 8, 7, 6], timestamp("2023-02-03T23:31:20Z")]])', + value: { + stringValue: + "[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]", + }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n [\n "abc"^#*expr.Constant_StringValue#,\n 3.14^#*expr.Constant_DoubleValue#,\n null^#*expr.Constant_NullValue#,\n [\n 9^#*expr.Constant_Int64Value#,\n 8^#*expr.Constant_Int64Value#,\n 7^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#,\n timestamp(\n "2023-02-03T23:31:20Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n [\n "abc"~string,\n 3.14~double,\n null~null,\n [\n 9~int,\n 8~int,\n 7~int,\n 6~int\n ]~list(int),\n timestamp(\n "2023-02-03T23:31:20Z"~string\n )~timestamp^string_to_timestamp\n ]~list(dyn)\n ]~list(list(dyn))\n)~string^string_format', + type: "string", + }, + { + original: { + name: "map support for string", + expr: '"%s".format([{"key1": b"xyz", "key5": null, "key2": duration("2h"), "key4": true, "key3": 2.71828}])', + value: { + stringValue: + "{key1: xyz, key2: 7200s, key3: 2.71828, key4: true, key5: null}", + }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n "key1"^#*expr.Constant_StringValue#:b"xyz"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#,\n "key5"^#*expr.Constant_StringValue#:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#,\n "key2"^#*expr.Constant_StringValue#:duration(\n "2h"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n "key4"^#*expr.Constant_StringValue#:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#,\n "key3"^#*expr.Constant_StringValue#:2.71828^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n {\n "key1"~string:b"xyz"~bytes,\n "key5"~string:null~null,\n "key2"~string:duration(\n "2h"~string\n )~duration^string_to_duration,\n "key4"~string:true~bool,\n "key3"~string:2.71828~double\n }~map(string, dyn)\n ]~list(map(string, dyn))\n)~string^string_format', + type: "string", + }, + { + original: { + name: "map support (all key types)", + expr: '"%s".format([{1: "value1", uint(2): "value2", true: double("NaN")}])', + value: { stringValue: "{1: value1, 2: value2, true: NaN}" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:"value1"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n uint(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#:"value2"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n {\n 1~int:"value1"~string,\n uint(\n 2~int\n )~uint^int64_to_uint64:"value2"~string,\n true~bool:double(\n "NaN"~string\n )~double^string_to_double\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format', + type: "string", + }, + { + original: { + name: "boolean support for %s", + expr: '"%s, %s".format([true, false])', + value: { stringValue: "true, false" }, + }, + ast: '"%s, %s"^#*expr.Constant_StringValue#.format(\n [\n true^#*expr.Constant_BoolValue#,\n false^#*expr.Constant_BoolValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s, %s"~string.format(\n [\n true~bool,\n false~bool\n ]~list(bool)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for string formatting clause", + expr: '"%s".format([dyn("a string")])', + value: { stringValue: "a string" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n "a string"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n dyn(\n "a string"~string\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for numbers with string formatting clause", + expr: '"%s, %s".format([dyn(32), dyn(56.8)])', + value: { stringValue: "32, 56.8" }, + }, + ast: '"%s, %s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 32^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 56.8^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s, %s"~string.format(\n [\n dyn(\n 32~int\n )~dyn^to_dyn,\n dyn(\n 56.8~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for integer formatting clause", + expr: '"%d".format([dyn(128)])', + value: { stringValue: "128" }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 128^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d"~string.format(\n [\n dyn(\n 128~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for integer formatting clause (unsigned)", + expr: '"%d".format([dyn(256u)])', + value: { stringValue: "256" }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 256u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%d"~string.format(\n [\n dyn(\n 256u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for hex formatting clause", + expr: '"%x".format([dyn(22)])', + value: { stringValue: "16" }, + }, + ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 22^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%x"~string.format(\n [\n dyn(\n 22~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for hex formatting clause (uppercase)", + expr: '"%X".format([dyn(26)])', + value: { stringValue: "1A" }, + }, + ast: '"%X"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 26^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%X"~string.format(\n [\n dyn(\n 26~int\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for unsigned hex formatting clause", + expr: '"%x".format([dyn(500u)])', + value: { stringValue: "1f4" }, + }, + ast: '"%x"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 500u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%x"~string.format(\n [\n dyn(\n 500u~uint\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for fixed-point formatting clause", + expr: '"%.3f".format([dyn(4.5)])', + value: { stringValue: "4.500" }, + }, + ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 4.5^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.3f"~string.format(\n [\n dyn(\n 4.5~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for scientific notation", + expr: '"%e".format([dyn(2.71828)])', + value: { stringValue: "2.718280e+00" }, + }, + ast: '"%e"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n 2.71828^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%e"~string.format(\n [\n dyn(\n 2.71828~double\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype NaN/infinity support", + expr: '"%s".format([[double("NaN"), double("Infinity"), double("-Infinity")]])', + value: { stringValue: "[NaN, Infinity, -Infinity]" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n [\n double(\n "NaN"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n "Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n double(\n "-Infinity"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n [\n double(\n "NaN"~string\n )~double^string_to_double,\n double(\n "Infinity"~string\n )~double^string_to_double,\n double(\n "-Infinity"~string\n )~double^string_to_double\n ]~list(double)\n ]~list(list(double))\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for timestamp", + expr: '"%s".format([dyn(timestamp("2009-11-10T23:00:00Z"))])', + value: { stringValue: "2009-11-10T23:00:00Z" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n timestamp(\n "2009-11-10T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n dyn(\n timestamp(\n "2009-11-10T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for duration", + expr: '"%s".format([dyn(duration("8747s"))])', + value: { stringValue: "8747s" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n duration(\n "8747s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n dyn(\n duration(\n "8747s"~string\n )~duration^string_to_duration\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for lists", + expr: '"%s".format([dyn([6, 4.2, "a string"])])', + value: { stringValue: "[6, 4.2, a string]" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n dyn(\n [\n 6^#*expr.Constant_Int64Value#,\n 4.2^#*expr.Constant_DoubleValue#,\n "a string"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n dyn(\n [\n 6~int,\n 4.2~double,\n "a string"~string\n ]~list(dyn)\n )~dyn^to_dyn\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "dyntype support for maps", + expr: '"%s".format([{"strKey":"x", 6:duration("422s"), true:42}])', + value: { stringValue: "{6: 422s, strKey: x, true: 42}" }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n "strKey"^#*expr.Constant_StringValue#:"x"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 6^#*expr.Constant_Int64Value#:duration(\n "422s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#,\n true^#*expr.Constant_BoolValue#:42^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%s"~string.format(\n [\n {\n "strKey"~string:"x"~string,\n 6~int:duration(\n "422s"~string\n )~duration^string_to_duration,\n true~bool:42~int\n }~map(dyn, dyn)\n ]~list(map(dyn, dyn))\n)~string^string_format', + type: "string", + }, + { + original: { + name: "string substitution in a string variable", + expr: 'str_var.format(["filler"])', + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { str_var: { value: { stringValue: "%s" } } }, + value: { stringValue: "filler" }, + }, + ast: 'str_var^#*expr.Expr_IdentExpr#.format(\n [\n "filler"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'str_var~string^str_var.format(\n [\n "filler"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "multiple substitutions in a string variable", + expr: 'str_var.format([1, 2, 3, "A", "B", "C", 4, 5, 6, "D", "E", "F"])', + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { + str_var: { + value: { + stringValue: "%d %d %d, %s %s %s, %d %d %d, %s %s %s", + }, + }, + }, + value: { stringValue: "1 2 3, A B C, 4 5 6, D E F" }, + }, + ast: 'str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#,\n "A"^#*expr.Constant_StringValue#,\n "B"^#*expr.Constant_StringValue#,\n "C"^#*expr.Constant_StringValue#,\n 4^#*expr.Constant_Int64Value#,\n 5^#*expr.Constant_Int64Value#,\n 6^#*expr.Constant_Int64Value#,\n "D"^#*expr.Constant_StringValue#,\n "E"^#*expr.Constant_StringValue#,\n "F"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'str_var~string^str_var.format(\n [\n 1~int,\n 2~int,\n 3~int,\n "A"~string,\n "B"~string,\n "C"~string,\n 4~int,\n 5~int,\n 6~int,\n "D"~string,\n "E"~string,\n "F"~string\n ]~list(dyn)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "substitution inside escaped percent signs in a string variable", + expr: 'str_var.format(["text"])', + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { str_var: { value: { stringValue: "%%%s%%" } } }, + value: { stringValue: "%text%" }, + }, + ast: 'str_var^#*expr.Expr_IdentExpr#.format(\n [\n "text"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'str_var~string^str_var.format(\n [\n "text"~string\n ]~list(string)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "fixed point formatting clause in a string variable", + expr: "str_var.format([1.2345])", + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { str_var: { value: { stringValue: "%.3f" } } }, + value: { stringValue: "1.234" }, + }, + ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1.2345^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "str_var~string^str_var.format(\n [\n 1.2345~double\n ]~list(double)\n)~string^string_format", + type: "string", + }, + { + original: { + name: "binary formatting clause in a string variable", + expr: "str_var.format([5])", + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { str_var: { value: { stringValue: "%b" } } }, + value: { stringValue: "101" }, + }, + ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 5^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "str_var~string^str_var.format(\n [\n 5~int\n ]~list(int)\n)~string^string_format", + type: "string", + }, + { + original: { + name: "scientific notation formatting clause in a string variable", + expr: "str_var.format([1052.032911275])", + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { str_var: { value: { stringValue: "%.6e" } } }, + value: { stringValue: "1.052033e+03" }, + }, + ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 1052.032911275^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "str_var~string^str_var.format(\n [\n 1052.032911275~double\n ]~list(double)\n)~string^string_format", + type: "string", + }, + { + original: { + name: "default precision for fixed-point clause in a string variable", + expr: "str_var.format([2.71828])", + typeEnv: [ + { name: "str_var", ident: { type: { primitive: "STRING" } } }, + ], + bindings: { str_var: { value: { stringValue: "%f" } } }, + value: { stringValue: "2.718280" }, + }, + ast: "str_var^#*expr.Expr_IdentExpr#.format(\n [\n 2.71828^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "str_var~string^str_var.format(\n [\n 2.71828~double\n ]~list(double)\n)~string^string_format", + type: "string", + }, + { + original: { + name: "format_%f_insignificant_zeroes_removed", + expr: '"%.0f".format([123.000000])', + value: { stringValue: "123" }, + }, + ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 123^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.0f"~string.format(\n [\n 123~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_positive_round_to_whole_number", + expr: '"%.0f".format([3.5001])', + value: { stringValue: "4" }, + }, + ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 3.5001^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.0f"~string.format(\n [\n 3.5001~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_negative_truncate_to_whole_number", + expr: '"%.0f".format([3.4999])', + value: { stringValue: "3" }, + }, + ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 3.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.0f"~string.format(\n [\n 3.4999~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_halfway_round_up_to_nearest_even", + expr: '"%.0f".format([1.5])', + value: { stringValue: "2" }, + }, + ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 1.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.0f"~string.format(\n [\n 1.5~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_halfway_truncate_to_nearest_even", + expr: '"%.0f".format([2.5])', + value: { stringValue: "2" }, + }, + ast: '"%.0f"^#*expr.Constant_StringValue#.format(\n [\n 2.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.0f"~string.format(\n [\n 2.5~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_positive_round_up", + expr: '"%.3f".format([123.4999])', + value: { stringValue: "123.500" }, + }, + ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n 123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.3f"~string.format(\n [\n 123.4999~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_positive_round_down", + expr: '"%.3f".format([123.4994])', + value: { stringValue: "123.499" }, + }, + ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n 123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.3f"~string.format(\n [\n 123.4994~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_negative_round_up", + expr: '"%.3f".format([-123.4999])', + value: { stringValue: "-123.500" }, + }, + ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n -123.4999^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.3f"~string.format(\n [\n -123.4999~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_negative_round_down", + expr: '"%.3f".format([-123.4994])', + value: { stringValue: "-123.499" }, + }, + ast: '"%.3f"^#*expr.Constant_StringValue#.format(\n [\n -123.4994^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.3f"~string.format(\n [\n -123.4994~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + { + original: { + name: "format_%f_zero_padding", + expr: '"%.5f".format([-1.2])', + value: { stringValue: "-1.20000" }, + }, + ast: '"%.5f"^#*expr.Constant_StringValue#.format(\n [\n -1.2^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '"%.5f"~string.format(\n [\n -1.2~double\n ]~list(double)\n)~string^string_format', + type: "string", + }, + ], + }, + { + name: "format_errors", + tests: [ + { + original: { + name: "unrecognized formatting clause", + expr: '"%a".format([1])', + disableCheck: true, + evalError: { + errors: [ + { + message: + 'could not parse formatting clause: unrecognized formatting clause "a"', + }, + ], + }, + }, + ast: '"%a"^#*expr.Constant_StringValue#.format(\n [\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:12: could not parse formatting clause: unrecognized formatting clause "a"\n | "%a".format([1])\n | ...........^', + }, + { + original: { + name: "out of bounds arg index", + expr: '"%d %d %d".format([0, 1])', + disableCheck: true, + evalError: { errors: [{ message: "index 2 out of range" }] }, + }, + ast: '"%d %d %d"^#*expr.Constant_StringValue#.format(\n [\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:18: index 2 out of range\n | "%d %d %d".format([0, 1])\n | .................^', + }, + { + original: { + name: "string substitution is not allowed with binary clause", + expr: '"string is %b".format(["abc"])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: only integers and bools can be formatted as binary, was given string", + }, + ], + }, + }, + ast: '"string is %b"^#*expr.Constant_StringValue#.format(\n [\n "abc"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, and bools can be formatted as binary, was given string\n | "string is %b".format(["abc"])\n | .......................^', + }, + { + original: { + name: "duration substitution not allowed with decimal clause", + expr: '"%d".format([duration("30m2s")])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: decimal clause can only be used on integers, was given google.protobuf.Duration", + }, + ], + }, + }, + ast: '"%d"^#*expr.Constant_StringValue#.format(\n [\n duration(\n "30m2s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:22: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given google.protobuf.Duration\n | "%d".format([duration("30m2s")])\n | .....................^', + }, + { + original: { + name: "string substitution not allowed with octal clause", + expr: '"octal: %o".format(["a string"])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: octal clause can only be used on integers, was given string", + }, + ], + }, + }, + ast: '"octal: %o"^#*expr.Constant_StringValue#.format(\n [\n "a string"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:21: error during formatting: octal clause can only be used on ints and uints, was given string\n | "octal: %o".format(["a string"])\n | ....................^', + }, + { + original: { + name: "double substitution not allowed with hex clause", + expr: '"double is %x".format([0.5])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given double", + }, + ], + }, + }, + ast: '"double is %x"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:24: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given double\n | "double is %x".format([0.5])\n | .......................^', + }, + { + original: { + name: "uppercase not allowed for scientific clause", + expr: '"double is %E".format([0.5])', + disableCheck: true, + evalError: { + errors: [ + { + message: + 'could not parse formatting clause: unrecognized formatting clause "E"', + }, + ], + }, + }, + ast: '"double is %E"^#*expr.Constant_StringValue#.format(\n [\n 0.5^#*expr.Constant_DoubleValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:22: could not parse formatting clause: unrecognized formatting clause "E"\n | "double is %E".format([0.5])\n | .....................^', + }, + { + original: { + name: "object not allowed", + expr: '"object is %s".format([cel.expr.conformance.proto3.TestAllTypes{}])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + }, + ast: '"object is %s"^#*expr.Constant_StringValue#.format(\n [\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:64: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | "object is %s".format([cel.expr.conformance.proto3.TestAllTypes{}])\n | ...............................................................^', + }, + { + original: { + name: "object inside list", + expr: '"%s".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n [\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:61: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | "%s".format([[1, 2, cel.expr.conformance.proto3.TestAllTypes{}]])\n | ............................................................^', + }, + { + original: { + name: "object inside map", + expr: '"%s".format([{1: "a", 2: cel.expr.conformance.proto3.TestAllTypes{}}])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + }, + ast: '"%s"^#*expr.Constant_StringValue#.format(\n [\n {\n 1^#*expr.Constant_Int64Value#:"a"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#,\n 2^#*expr.Constant_Int64Value#:cel.expr.conformance.proto3.TestAllTypes{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:66: error during formatting: string clause can only be used on strings, bools, bytes, ints, doubles, maps, lists, types, durations, and timestamps, was given cel.expr.conformance.proto3.TestAllTypes\n | "%s".format([{1: "a", 2: cel.expr.conformance.proto3.TestAllTypes{}}])\n | .................................................................^', + }, + { + original: { + name: "null not allowed for %d", + expr: '"null: %d".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: decimal clause can only be used on integers, was given null_type", + }, + ], + }, + }, + ast: '"null: %d"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: decimal clause can only be used on ints, uints, and doubles, was given null_type\n | "null: %d".format([null])\n | ...................^', + }, + { + original: { + name: "null not allowed for %e", + expr: '"null: %e".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: scientific clause can only be used on doubles, was given null_type", + }, + ], + }, + }, + ast: '"null: %e"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: scientific clause can only be used on ints, uints, and doubles, was given null_type\n | "null: %e".format([null])\n | ...................^', + }, + { + original: { + name: "null not allowed for %f", + expr: '"null: %f".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: fixed-point clause can only be used on doubles, was given null_type", + }, + ], + }, + }, + ast: '"null: %f"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: fixed-point clause can only be used on ints, uints, and doubles, was given null_type\n | "null: %f".format([null])\n | ...................^', + }, + { + original: { + name: "null not allowed for %x", + expr: '"null: %x".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type", + }, + ], + }, + }, + ast: '"null: %x"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | "null: %x".format([null])\n | ...................^', + }, + { + original: { + name: "null not allowed for %X", + expr: '"null: %X".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: only integers, byte buffers, and strings can be formatted as hex, was given null_type", + }, + ], + }, + }, + ast: '"null: %X"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, bytes, and strings can be formatted as hex, was given null_type\n | "null: %X".format([null])\n | ...................^', + }, + { + original: { + name: "null not allowed for %b", + expr: '"null: %b".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: only integers and bools can be formatted as binary, was given null_type", + }, + ], + }, + }, + ast: '"null: %b"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: only ints, uints, and bools can be formatted as binary, was given null_type\n | "null: %b".format([null])\n | ...................^', + }, + { + original: { + name: "null not allowed for %o", + expr: '"null: %o".format([null])', + disableCheck: true, + evalError: { + errors: [ + { + message: + "error during formatting: octal clause can only be used on integers, was given null_type", + }, + ], + }, + }, + ast: '"null: %o"^#*expr.Constant_StringValue#.format(\n [\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + 'ERROR: \u003cinput\u003e:1:20: error during formatting: octal clause can only be used on ints and uints, was given null_type\n | "null: %o".format([null])\n | ...................^', + }, + ], + }, + { + name: "value_errors", + tests: [ + { + original: { + name: "charat_out_of_range", + expr: "'tacocat'.charAt(30) == ''", + evalError: { errors: [{ message: "index out of range: 30" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.charAt(\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.charAt(\n 30~int\n )~string^string_char_at_int,\n ""~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "indexof_out_of_range", + expr: "'tacocat'.indexOf('a', 30) == -1", + evalError: { errors: [{ message: "index out of range: 30" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.indexOf(\n "a"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.indexOf(\n "a"~string,\n 30~int\n )~int^string_index_of_string_int,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "lastindexof_negative_index", + expr: "'tacocat'.lastIndexOf('a', -1) == -1", + evalError: { errors: [{ message: "index out of range: -1" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "a"^#*expr.Constant_StringValue#,\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n "a"~string,\n -1~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "lastindexof_out_of_range", + expr: "'tacocat'.lastIndexOf('a', 30) == -1", + evalError: { errors: [{ message: "index out of range: 30" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.lastIndexOf(\n "a"^#*expr.Constant_StringValue#,\n 30^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n -1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.lastIndexOf(\n "a"~string,\n 30~int\n )~int^string_last_index_of_string_int,\n -1~int\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "substring_out_of_range", + expr: "'tacocat'.substring(40) == 'cat'", + evalError: { errors: [{ message: "index out of range: 40" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 40^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 40~int\n )~string^string_substring_int,\n "cat"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "substring_negative_index", + expr: "'tacocat'.substring(-1) == 'cat'", + evalError: { errors: [{ message: "index out of range: -1" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n -1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n -1~int\n )~string^string_substring_int,\n "cat"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "substring_end_index_out_of_range", + expr: "'tacocat'.substring(1, 50) == 'cat'", + evalError: { errors: [{ message: "index out of range: 50" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 1~int,\n 50~int\n )~string^string_substring_int_int,\n "cat"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "substring_begin_index_out_of_range", + expr: "'tacocat'.substring(49, 50) == 'cat'", + evalError: { errors: [{ message: "index out of range: 49" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 49^#*expr.Constant_Int64Value#,\n 50^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "cat"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 49~int,\n 50~int\n )~string^string_substring_int_int,\n "cat"~string\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "substring_end_index_greater_than_begin_index", + expr: "'tacocat'.substring(4, 3) == ''", + evalError: { + errors: [ + { message: "invalid substring range. start: 4, end: 3" }, + ], + }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 4^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n "tacocat"~string.substring(\n 4~int,\n 3~int\n )~string^string_substring_int_int,\n ""~string\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "type_errors", + tests: [ + { + original: { + name: "charat_invalid_type", + expr: "42.charAt(2) == ''", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.charAt(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:10: found no matching overload for 'charAt' applied to 'int.(int)'\n | 42.charAt(2) == ''\n | .........^", + }, + { + original: { + name: "charat_invalid_argument", + expr: "'hello'.charAt(true) == ''", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "hello"^#*expr.Constant_StringValue#.charAt(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:15: found no matching overload for 'charAt' applied to 'string.(bool)'\n | 'hello'.charAt(true) == ''\n | ..............^", + }, + { + original: { + name: "indexof_unary_invalid_type", + expr: "24.indexOf('2') == 0", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 24^#*expr.Constant_Int64Value#.indexOf(\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string)'\n | 24.indexOf('2') == 0\n | ..........^", + }, + { + original: { + name: "indexof_unary_invalid_argument", + expr: "'hello'.indexOf(true) == 1", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "hello"^#*expr.Constant_StringValue#.indexOf(\n true^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:16: found no matching overload for 'indexOf' applied to 'string.(bool)'\n | 'hello'.indexOf(true) == 1\n | ...............^", + }, + { + original: { + name: "indexof_binary_invalid_argument", + expr: "42.indexOf('4', 0) == 0", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.indexOf(\n "4"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'indexOf' applied to 'int.(string, int)'\n | 42.indexOf('4', 0) == 0\n | ..........^", + }, + { + original: { + name: "indexof_binary_invalid_argument_2", + expr: "'42'.indexOf(4, 0) == 0", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.indexOf(\n 4^#*expr.Constant_Int64Value#,\n 0^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(int, int)'\n | '42'.indexOf(4, 0) == 0\n | ............^", + }, + { + original: { + name: "indexof_binary_both_invalid_arguments", + expr: "'42'.indexOf('4', '0') == 0", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.indexOf(\n "4"^#*expr.Constant_StringValue#,\n "0"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, string)'\n | '42'.indexOf('4', '0') == 0\n | ............^", + }, + { + original: { + name: "indexof_ternary_invalid_arguments", + expr: "'42'.indexOf('4', 0, 1) == 0", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.indexOf(\n "4"^#*expr.Constant_StringValue#,\n 0^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'indexOf' applied to 'string.(string, int, int)'\n | '42'.indexOf('4', 0, 1) == 0\n | ............^", + }, + { + original: { + name: "split_invalid_type", + expr: "42.split('2') == ['4']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.split(\n "2"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('2') == ['4']\n | ........^", + }, + { + original: { + name: "replace_invalid_type", + expr: "42.replace(2, 1) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(int, int)'\n | 42.replace(2, 1) == '41'\n | ..........^", + }, + { + original: { + name: "replace_binary_invalid_argument", + expr: "'42'.replace(2, 1) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, int)'\n | '42'.replace(2, 1) == '41'\n | ............^", + }, + { + original: { + name: "replace_binary_invalid_argument_2", + expr: "'42'.replace('2', 1) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int)'\n | '42'.replace('2', 1) == '41'\n | ............^", + }, + { + original: { + name: "replace_ternary_invalid_argument", + expr: "42.replace('2', '1', 1) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.replace(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'replace' applied to 'int.(string, string, int)'\n | 42.replace('2', '1', 1) == '41'\n | ..........^", + }, + { + original: { + name: "replace_ternary_invalid_argument_2", + expr: "'42'.replace(2, '1', 1) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n 2^#*expr.Constant_Int64Value#,\n "1"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(int, string, int)'\n | '42'.replace(2, '1', 1) == '41'\n | ............^", + }, + { + original: { + name: "replace_ternary_invalid_argument_3", + expr: "'42'.replace('2', 1, 1) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, int, int)'\n | '42'.replace('2', 1, 1) == '41'\n | ............^", + }, + { + original: { + name: "replace_ternary_invalid_argument_4", + expr: "'42'.replace('2', '1', '1') == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, string)'\n | '42'.replace('2', '1', '1') == '41'\n | ............^", + }, + { + original: { + name: "replace_quaternary_invalid_argument", + expr: "'42'.replace('2', '1', 1, false) == '41'", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.replace(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n "41"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'replace' applied to 'string.(string, string, int, bool)'\n | '42'.replace('2', '1', 1, false) == '41'\n | ............^", + }, + { + original: { + name: "split_invalid_type_empty_arg", + expr: "42.split('') == ['4', '2']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.split(\n ""^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#,\n "2"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string)'\n | 42.split('') == ['4', '2']\n | ........^", + }, + { + original: { + name: "split_invalid_argument", + expr: "'42'.split(2) == ['4']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int)'\n | '42'.split(2) == ['4']\n | ..........^", + }, + { + original: { + name: "split_binary_invalid_type", + expr: "42.split('2', '1') == ['4']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 42^#*expr.Constant_Int64Value#.split(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:9: found no matching overload for 'split' applied to 'int.(string, string)'\n | 42.split('2', '1') == ['4']\n | ........^", + }, + { + original: { + name: "split_binary_invalid_argument", + expr: "'42'.split(2, 1) == ['4']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n 2^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(int, int)'\n | '42'.split(2, 1) == ['4']\n | ..........^", + }, + { + original: { + name: "split_binary_invalid_argument_2", + expr: "'42'.split('2', '1') == ['4']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n "2"^#*expr.Constant_StringValue#,\n "1"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, string)'\n | '42'.split('2', '1') == ['4']\n | ..........^", + }, + { + original: { + name: "split_ternary_invalid_argument", + expr: "'42'.split('2', 1, 1) == ['4']", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "42"^#*expr.Constant_StringValue#.split(\n "2"^#*expr.Constant_StringValue#,\n 1^#*expr.Constant_Int64Value#,\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n [\n "4"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:11: found no matching overload for 'split' applied to 'string.(string, int, int)'\n | '42'.split('2', 1, 1) == ['4']\n | ..........^", + }, + { + original: { + name: "substring_ternary_invalid_argument", + expr: "'hello'.substring(1, 2, 3) == ''", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "hello"^#*expr.Constant_StringValue#.substring(\n 1^#*expr.Constant_Int64Value#,\n 2^#*expr.Constant_Int64Value#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:18: found no matching overload for 'substring' applied to 'string.(int, int, int)'\n | 'hello'.substring(1, 2, 3) == ''\n | .................^", + }, + { + original: { + name: "substring_binary_invalid_type", + expr: "30.substring(true, 3) == ''", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n 30^#*expr.Constant_Int64Value#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:13: found no matching overload for 'substring' applied to 'int.(bool, int)'\n | 30.substring(true, 3) == ''\n | ............^", + }, + { + original: { + name: "substring_binary_invalid_argument", + expr: "'tacocat'.substring(true, 3) == ''", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n true^#*expr.Constant_BoolValue#,\n 3^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(bool, int)'\n | 'tacocat'.substring(true, 3) == ''\n | ...................^", + }, + { + original: { + name: "substring_binary_invalid_argument_2", + expr: "'tacocat'.substring(0, false) == ''", + disableCheck: true, + evalError: { errors: [{ message: "no such overload" }] }, + }, + ast: '_==_(\n "tacocat"^#*expr.Constant_StringValue#.substring(\n 0^#*expr.Constant_Int64Value#,\n false^#*expr.Constant_BoolValue#\n )^#*expr.Expr_CallExpr#,\n ""^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + error: + "ERROR: \u003cinput\u003e:1:20: found no matching overload for 'substring' applied to 'string.(int, bool)'\n | 'tacocat'.substring(0, false) == ''\n | ...................^", + }, + ], + }, + ], + }, + { + name: "timestamps", + suites: [ + { + name: "timestamp_conversions", + tests: [ + { + original: { + name: "toInt_timestamp", + expr: "int(timestamp('2009-02-13T23:31:30Z'))", + value: { int64Value: "1234567890" }, + }, + ast: 'int(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'int(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~int^timestamp_to_int64', + type: "int", + }, + { + original: { + name: "toString_timestamp", + expr: "string(timestamp('2009-02-13T23:31:30Z'))", + value: { stringValue: "2009-02-13T23:31:30Z" }, + }, + ast: 'string(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'string(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string', + type: "string", + }, + { + original: { + name: "toString_timestamp_nanos", + expr: "string(timestamp('9999-12-31T23:59:59.999999999Z'))", + value: { stringValue: "9999-12-31T23:59:59.999999999Z" }, + }, + ast: 'string(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'string(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"~string\n )~timestamp^string_to_timestamp\n)~string^timestamp_to_string', + type: "string", + }, + { + original: { + name: "toType_timestamp", + expr: "type(timestamp('2009-02-13T23:31:30Z'))", + value: { typeValue: "google.protobuf.Timestamp" }, + }, + ast: 'type(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'type(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~type(timestamp)^type', + type: "type(timestamp)", + }, + { + original: { + name: "type_comparison", + expr: "google.protobuf.Timestamp == type(timestamp('2009-02-13T23:31:30Z'))", + value: { boolValue: true }, + }, + ast: '_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Timestamp^#*expr.Expr_SelectExpr#,\n type(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n google.protobuf.Timestamp~type(timestamp)^google.protobuf.Timestamp,\n type(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n )~type(timestamp)^type\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "duration_conversions", + tests: [ + { + original: { + name: "toString_duration", + expr: "string(duration('1000000s'))", + value: { stringValue: "1000000s" }, + }, + ast: 'string(\n duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'string(\n duration(\n "1000000s"~string\n )~duration^string_to_duration\n)~string^duration_to_string', + type: "string", + }, + { + original: { + name: "toType_duration", + expr: "type(duration('1000000s'))", + value: { typeValue: "google.protobuf.Duration" }, + }, + ast: 'type(\n duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'type(\n duration(\n "1000000s"~string\n )~duration^string_to_duration\n)~type(duration)^type', + type: "type(duration)", + }, + { + original: { + name: "type_comparison", + expr: "google.protobuf.Duration == type(duration('1000000s'))", + value: { boolValue: true }, + }, + ast: '_==_(\n google^#*expr.Expr_IdentExpr#.protobuf^#*expr.Expr_SelectExpr#.Duration^#*expr.Expr_SelectExpr#,\n type(\n duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n google.protobuf.Duration~type(duration)^google.protobuf.Duration,\n type(\n duration(\n "1000000s"~string\n )~duration^string_to_duration\n )~type(duration)^type\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "timestamp_selectors", + tests: [ + { + original: { + name: "getDate", + expr: "timestamp('2009-02-13T23:31:30Z').getDate()", + value: { int64Value: "13" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDate()~int^timestamp_to_day_of_month_1_based', + type: "int", + }, + { + original: { + name: "getDayOfMonth", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfMonth()", + value: { int64Value: "12" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth()~int^timestamp_to_day_of_month', + type: "int", + }, + { + original: { + name: "getDayOfWeek", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfWeek()", + value: { int64Value: "5" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfWeek()~int^timestamp_to_day_of_week', + type: "int", + }, + { + original: { + name: "getDayOfYear", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfYear()", + value: { int64Value: "43" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfYear()~int^timestamp_to_day_of_year', + type: "int", + }, + { + original: { + name: "getFullYear", + expr: "timestamp('2009-02-13T23:31:30Z').getFullYear()", + value: { int64Value: "2009" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getFullYear()~int^timestamp_to_year', + type: "int", + }, + { + original: { + name: "getHours", + expr: "timestamp('2009-02-13T23:31:30Z').getHours()", + value: { int64Value: "23" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getHours()~int^timestamp_to_hours', + type: "int", + }, + { + original: { + name: "getMilliseconds", + expr: "timestamp('2009-02-13T23:31:20.123456789Z').getMilliseconds()", + value: { int64Value: "123" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:20.123456789Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMilliseconds()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:20.123456789Z"~string\n)~timestamp^string_to_timestamp.getMilliseconds()~int^timestamp_to_milliseconds', + type: "int", + }, + { + original: { + name: "getMinutes", + expr: "timestamp('2009-02-13T23:31:30Z').getMinutes()", + value: { int64Value: "31" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMinutes()~int^timestamp_to_minutes', + type: "int", + }, + { + original: { + name: "getMonth", + expr: "timestamp('2009-02-13T23:31:30Z').getMonth()", + value: { int64Value: "1" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMonth()~int^timestamp_to_month', + type: "int", + }, + { + original: { + name: "getSeconds", + expr: "timestamp('2009-02-13T23:31:30Z').getSeconds()", + value: { int64Value: "30" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getSeconds()~int^timestamp_to_seconds', + type: "int", + }, + ], + }, + { + name: "timestamp_selectors_tz", + tests: [ + { + original: { + name: "getDate", + expr: "timestamp('2009-02-13T23:31:30Z').getDate('Australia/Sydney')", + value: { int64Value: "14" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDate(\n "Australia/Sydney"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDate(\n "Australia/Sydney"~string\n)~int^timestamp_to_day_of_month_1_based_with_tz', + type: "int", + }, + { + original: { + name: "getDayOfMonth_name_pos", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfMonth('US/Central')", + value: { int64Value: "12" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "US/Central"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "US/Central"~string\n)~int^timestamp_to_day_of_month_with_tz', + type: "int", + }, + { + original: { + name: "getDayOfMonth_numerical_pos", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfMonth('+11:00')", + value: { int64Value: "13" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "+11:00"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "+11:00"~string\n)~int^timestamp_to_day_of_month_with_tz', + type: "int", + }, + { + original: { + name: "getDayOfMonth_numerical_neg", + expr: "timestamp('2009-02-13T02:00:00Z').getDayOfMonth('-02:30')", + value: { int64Value: "11" }, + }, + ast: 'timestamp(\n "2009-02-13T02:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "-02:30"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T02:00:00Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "-02:30"~string\n)~int^timestamp_to_day_of_month_with_tz', + type: "int", + }, + { + original: { + name: "getDayOfMonth_name_neg", + expr: "timestamp('2009-02-13T02:00:00Z').getDayOfMonth('America/St_Johns')", + value: { int64Value: "11" }, + }, + ast: 'timestamp(\n "2009-02-13T02:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfMonth(\n "America/St_Johns"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T02:00:00Z"~string\n)~timestamp^string_to_timestamp.getDayOfMonth(\n "America/St_Johns"~string\n)~int^timestamp_to_day_of_month_with_tz', + type: "int", + }, + { + original: { + name: "getDayOfWeek", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfWeek('UTC')", + value: { int64Value: "5" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfWeek(\n "UTC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfWeek(\n "UTC"~string\n)~int^timestamp_to_day_of_week_with_tz', + type: "int", + }, + { + original: { + name: "getDayOfYear", + expr: "timestamp('2009-02-13T23:31:30Z').getDayOfYear('US/Central')", + value: { int64Value: "43" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getDayOfYear(\n "US/Central"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getDayOfYear(\n "US/Central"~string\n)~int^timestamp_to_day_of_year_with_tz', + type: "int", + }, + { + original: { + name: "getFullYear", + expr: "timestamp('2009-02-13T23:31:30Z').getFullYear('-09:30')", + value: { int64Value: "2009" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getFullYear(\n "-09:30"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getFullYear(\n "-09:30"~string\n)~int^timestamp_to_year_with_tz', + type: "int", + }, + { + original: { + name: "getHours", + expr: "timestamp('2009-02-13T23:31:30Z').getHours('02:00')", + value: { int64Value: "1" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours(\n "02:00"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getHours(\n "02:00"~string\n)~int^timestamp_to_hours_with_tz', + type: "int", + }, + { + original: { + name: "getMinutes", + expr: "timestamp('2009-02-13T23:31:30Z').getMinutes('Asia/Kathmandu')", + value: { int64Value: "16" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes(\n "Asia/Kathmandu"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMinutes(\n "Asia/Kathmandu"~string\n)~int^timestamp_to_minutes_with_tz', + type: "int", + }, + { + original: { + name: "getMonth", + expr: "timestamp('2009-02-13T23:31:30Z').getMonth('UTC')", + value: { int64Value: "1" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMonth(\n "UTC"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getMonth(\n "UTC"~string\n)~int^timestamp_to_month_with_tz', + type: "int", + }, + { + original: { + name: "getSeconds", + expr: "timestamp('2009-02-13T23:31:30Z').getSeconds('-00:00')", + value: { int64Value: "30" }, + }, + ast: 'timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds(\n "-00:00"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "2009-02-13T23:31:30Z"~string\n)~timestamp^string_to_timestamp.getSeconds(\n "-00:00"~string\n)~int^timestamp_to_seconds_tz', + type: "int", + }, + ], + }, + { + name: "timestamp_equality", + tests: [ + { + original: { + name: "eq_same", + expr: "timestamp('2009-02-13T23:31:30Z') == timestamp('2009-02-13T23:31:30Z')", + value: { boolValue: true }, + }, + ast: '_==_(\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_diff", + expr: "timestamp('2009-02-13T23:31:29Z') == timestamp('2009-02-13T23:31:30Z')", + value: { boolValue: false }, + }, + ast: '_==_(\n timestamp(\n "2009-02-13T23:31:29Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:31:30Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n timestamp(\n "2009-02-13T23:31:29Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:31:30Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "neq_same", + expr: "timestamp('1945-05-07T02:41:00Z') != timestamp('1945-05-07T02:41:00Z')", + value: { boolValue: false }, + }, + ast: '_!=_(\n timestamp(\n "1945-05-07T02:41:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "1945-05-07T02:41:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n timestamp(\n "1945-05-07T02:41:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "1945-05-07T02:41:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "neq_diff", + expr: "timestamp('2000-01-01T00:00:00Z') != timestamp('2001-01-01T00:00:00Z')", + value: { boolValue: true }, + }, + ast: '_!=_(\n timestamp(\n "2000-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n timestamp(\n "2000-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^not_equals', + type: "bool", + }, + ], + }, + { + name: "duration_equality", + tests: [ + { + original: { + name: "eq_same", + expr: "duration('123s') == duration('123s')", + value: { boolValue: true }, + }, + ast: '_==_(\n duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "123s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n duration(\n "123s"~string\n )~duration^string_to_duration,\n duration(\n "123s"~string\n )~duration^string_to_duration\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "eq_diff", + expr: "duration('60s') == duration('3600s')", + value: { boolValue: false }, + }, + ast: '_==_(\n duration(\n "60s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "3600s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n duration(\n "60s"~string\n )~duration^string_to_duration,\n duration(\n "3600s"~string\n )~duration^string_to_duration\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "neq_same", + expr: "duration('604800s') != duration('604800s')", + value: { boolValue: false }, + }, + ast: '_!=_(\n duration(\n "604800s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "604800s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n duration(\n "604800s"~string\n )~duration^string_to_duration,\n duration(\n "604800s"~string\n )~duration^string_to_duration\n)~bool^not_equals', + type: "bool", + }, + { + original: { + name: "neq_diff", + expr: "duration('86400s') != duration('86164s')", + value: { boolValue: true }, + }, + ast: '_!=_(\n duration(\n "86400s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "86164s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_!=_(\n duration(\n "86400s"~string\n )~duration^string_to_duration,\n duration(\n "86164s"~string\n )~duration^string_to_duration\n)~bool^not_equals', + type: "bool", + }, + ], + }, + { + name: "timestamp_arithmetic", + tests: [ + { + original: { + name: "add_duration_to_time", + expr: "timestamp('2009-02-13T23:00:00Z') + duration('240s') == timestamp('2009-02-13T23:04:00Z')", + value: { boolValue: true }, + }, + ast: '_==_(\n _+_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "240s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:04:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _+_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "240s"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n "2009-02-13T23:04:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "add_time_to_duration", + expr: "duration('120s') + timestamp('2009-02-13T23:01:00Z') == timestamp('2009-02-13T23:03:00Z')", + value: { boolValue: true }, + }, + ast: '_==_(\n _+_(\n duration(\n "120s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:01:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:03:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _+_(\n duration(\n "120s"~string\n )~duration^string_to_duration,\n timestamp(\n "2009-02-13T23:01:00Z"~string\n )~timestamp^string_to_timestamp\n )~timestamp^add_duration_timestamp,\n timestamp(\n "2009-02-13T23:03:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "add_duration_to_duration", + expr: "duration('600s') + duration('50s') == duration('650s')", + value: { boolValue: true }, + }, + ast: '_==_(\n _+_(\n duration(\n "600s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "50s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "650s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _+_(\n duration(\n "600s"~string\n )~duration^string_to_duration,\n duration(\n "50s"~string\n )~duration^string_to_duration\n )~duration^add_duration_duration,\n duration(\n "650s"~string\n )~duration^string_to_duration\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "add_time_to_duration_nanos_negative", + expr: "timestamp('0001-01-01T00:00:01.000000001Z') + duration('-999999999ns') == timestamp('0001-01-01T00:00:00.000000002Z')", + value: { boolValue: true }, + }, + ast: '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.000000001Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-999999999ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "0001-01-01T00:00:00.000000002Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.000000001Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "-999999999ns"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n "0001-01-01T00:00:00.000000002Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "add_time_to_duration_nanos_positive", + expr: "timestamp('0001-01-01T00:00:01.999999999Z') + duration('999999999ns') == timestamp('0001-01-01T00:00:02.999999998Z')", + value: { boolValue: true }, + }, + ast: '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "999999999ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "0001-01-01T00:00:02.999999998Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _+_(\n timestamp(\n "0001-01-01T00:00:01.999999999Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "999999999ns"~string\n )~duration^string_to_duration\n )~timestamp^add_timestamp_duration,\n timestamp(\n "0001-01-01T00:00:02.999999998Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "subtract_duration_from_time", + expr: "timestamp('2009-02-13T23:10:00Z') - duration('600s') == timestamp('2009-02-13T23:00:00Z')", + value: { boolValue: true }, + }, + ast: '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:10:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "600s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:10:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "600s"~string\n )~duration^string_to_duration\n )~timestamp^subtract_timestamp_duration,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "subtract_time_from_time", + expr: "timestamp('2009-02-13T23:31:00Z') - timestamp('2009-02-13T23:29:00Z') == duration('120s')", + value: { boolValue: true }, + }, + ast: '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:31:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:29:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "120s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _-_(\n timestamp(\n "2009-02-13T23:31:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:29:00Z"~string\n )~timestamp^string_to_timestamp\n )~duration^subtract_timestamp_timestamp,\n duration(\n "120s"~string\n )~duration^string_to_duration\n)~bool^equals', + type: "bool", + }, + { + original: { + name: "subtract_duration_from_duration", + expr: "duration('900s') - duration('42s') == duration('858s')", + value: { boolValue: true }, + }, + ast: '_==_(\n _-_(\n duration(\n "900s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "42s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n duration(\n "858s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_==_(\n _-_(\n duration(\n "900s"~string\n )~duration^string_to_duration,\n duration(\n "42s"~string\n )~duration^string_to_duration\n )~duration^subtract_duration_duration,\n duration(\n "858s"~string\n )~duration^string_to_duration\n)~bool^equals', + type: "bool", + }, + ], + }, + { + name: "comparisons", + tests: [ + { + original: { + name: "leq_timestamp_true", + expr: "timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T23:00:00Z')", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp', + type: "bool", + }, + { + original: { + name: "leq_timestamp_false", + expr: "timestamp('2009-02-13T23:00:00Z') \u003c= timestamp('2009-02-13T22:59:59Z')", + value: { boolValue: false }, + }, + ast: '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T22:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T22:59:59Z"~string\n )~timestamp^string_to_timestamp\n)~bool^less_equals_timestamp', + type: "bool", + }, + { + original: { + name: "leq_duration_true", + expr: "duration('200s') \u003c= duration('200s')", + value: { boolValue: true }, + }, + ast: '_\u003c=_(\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n duration(\n "200s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration', + type: "bool", + }, + { + original: { + name: "leq_duration_false", + expr: "duration('300s') \u003c= duration('200s')", + value: { boolValue: false }, + }, + ast: '_\u003c=_(\n duration(\n "300s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c=_(\n duration(\n "300s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^less_equals_duration', + type: "bool", + }, + { + original: { + name: "less_timestamp_true", + expr: "timestamp('2009-02-13T23:00:00Z') \u003c timestamp('2009-03-13T23:00:00Z')", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-03-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-03-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^less_timestamp', + type: "bool", + }, + { + original: { + name: "less_duration_true", + expr: "duration('200s') \u003c duration('300s')", + value: { boolValue: true }, + }, + ast: '_\u003c_(\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "300s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003c_(\n duration(\n "200s"~string\n )~duration^string_to_duration,\n duration(\n "300s"~string\n )~duration^string_to_duration\n)~bool^less_duration', + type: "bool", + }, + { + original: { + name: "geq_timestamp_true", + expr: "timestamp('2009-02-13T23:00:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp', + type: "bool", + }, + { + original: { + name: "geq_timestamp_false", + expr: "timestamp('2009-02-13T22:58:00Z') \u003e= timestamp('2009-02-13T23:00:00Z')", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n timestamp(\n "2009-02-13T22:58:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n timestamp(\n "2009-02-13T22:58:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_equals_timestamp', + type: "bool", + }, + { + original: { + name: "geq_duration_true", + expr: "duration('200s') \u003e= duration('200s')", + value: { boolValue: true }, + }, + ast: '_\u003e=_(\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n duration(\n "200s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration', + type: "bool", + }, + { + original: { + name: "geq_duration_false", + expr: "duration('120s') \u003e= duration('200s')", + value: { boolValue: false }, + }, + ast: '_\u003e=_(\n duration(\n "120s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e=_(\n duration(\n "120s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^greater_equals_duration', + type: "bool", + }, + { + original: { + name: "greater_timestamp_true", + expr: "timestamp('2009-02-13T23:59:00Z') \u003e timestamp('2009-02-13T23:00:00Z')", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n timestamp(\n "2009-02-13T23:59:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "2009-02-13T23:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n timestamp(\n "2009-02-13T23:59:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "2009-02-13T23:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~bool^greater_timestamp', + type: "bool", + }, + { + original: { + name: "greater_duration_true", + expr: "duration('300s') \u003e duration('200s')", + value: { boolValue: true }, + }, + ast: '_\u003e_(\n duration(\n "300s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_\u003e_(\n duration(\n "300s"~string\n )~duration^string_to_duration,\n duration(\n "200s"~string\n )~duration^string_to_duration\n)~bool^greater_duration', + type: "bool", + }, + ], + }, + { + name: "duration_converters", + tests: [ + { + original: { + name: "get_hours", + expr: "duration('10000s').getHours()", + value: { int64Value: "2" }, + }, + ast: 'duration(\n "10000s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getHours()^#*expr.Expr_CallExpr#', + checkedAst: + 'duration(\n "10000s"~string\n)~duration^string_to_duration.getHours()~int^duration_to_hours', + type: "int", + }, + { + original: { + name: "get_milliseconds", + description: + "Obtain the milliseconds component of the duration. Note, this is not the same as converting the duration to milliseconds. This behavior will be deprecated.", + expr: "x.getMilliseconds()", + typeEnv: [ + { + name: "x", + ident: { + type: { messageType: "google.protobuf.Duration" }, + }, + }, + ], + bindings: { + x: { + value: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Duration", + value: "123.321456789s", + }, + }, + }, + }, + value: { int64Value: "321" }, + }, + ast: "x^#*expr.Expr_IdentExpr#.getMilliseconds()^#*expr.Expr_CallExpr#", + checkedAst: + "x~duration^x.getMilliseconds()~int^duration_to_milliseconds", + type: "int", + }, + { + original: { + name: "get_minutes", + expr: "duration('3730s').getMinutes()", + value: { int64Value: "62" }, + }, + ast: 'duration(\n "3730s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getMinutes()^#*expr.Expr_CallExpr#', + checkedAst: + 'duration(\n "3730s"~string\n)~duration^string_to_duration.getMinutes()~int^duration_to_minutes', + type: "int", + }, + { + original: { + name: "get_seconds", + expr: "duration('3730s').getSeconds()", + value: { int64Value: "3730" }, + }, + ast: 'duration(\n "3730s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.getSeconds()^#*expr.Expr_CallExpr#', + checkedAst: + 'duration(\n "3730s"~string\n)~duration^string_to_duration.getSeconds()~int^duration_to_seconds', + type: "int", + }, + ], + }, + { + name: "timestamp_range", + tests: [ + { + original: { + name: "from_string_under", + expr: "timestamp('0000-01-01T00:00:00Z')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: 'timestamp(\n "0000-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "0000-01-01T00:00:00Z"~string\n)~timestamp^string_to_timestamp', + type: "timestamp", + }, + { + original: { + name: "from_string_over", + expr: "timestamp('10000-01-01T00:00:00Z')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: 'timestamp(\n "10000-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'timestamp(\n "10000-01-01T00:00:00Z"~string\n)~timestamp^string_to_timestamp', + type: "timestamp", + }, + { + original: { + name: "add_duration_under", + expr: "timestamp('0001-01-01T00:00:00Z') + duration('-1s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-1s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "-1s"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', + type: "timestamp", + }, + { + original: { + name: "add_duration_over", + expr: "timestamp('9999-12-31T23:59:59Z') + duration('1s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_+_(\n timestamp(\n "9999-12-31T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "1s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n timestamp(\n "9999-12-31T23:59:59Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "1s"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', + type: "timestamp", + }, + { + original: { + name: "add_duration_nanos_over", + expr: "timestamp('9999-12-31T23:59:59.999999999Z') + duration('1ns')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_+_(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "1ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n timestamp(\n "9999-12-31T23:59:59.999999999Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "1ns"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', + type: "timestamp", + }, + { + original: { + name: "add_duration_nanos_under", + expr: "timestamp('0001-01-01T00:00:00Z') + duration('-1ns')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-1ns"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n duration(\n "-1ns"~string\n )~duration^string_to_duration\n)~timestamp^add_timestamp_duration', + type: "timestamp", + }, + { + original: { + name: "sub_time_duration_over", + expr: "timestamp('9999-12-31T23:59:59Z') - timestamp('0001-01-01T00:00:00Z')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_-_(\n timestamp(\n "9999-12-31T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_-_(\n timestamp(\n "9999-12-31T23:59:59Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp', + type: "duration", + }, + { + original: { + name: "sub_time_duration_under", + expr: "timestamp('0001-01-01T00:00:00Z') - timestamp('9999-12-31T23:59:59Z')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_-_(\n timestamp(\n "0001-01-01T00:00:00Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n timestamp(\n "9999-12-31T23:59:59Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_-_(\n timestamp(\n "0001-01-01T00:00:00Z"~string\n )~timestamp^string_to_timestamp,\n timestamp(\n "9999-12-31T23:59:59Z"~string\n )~timestamp^string_to_timestamp\n)~duration^subtract_timestamp_timestamp', + type: "duration", + }, + ], + }, + { + name: "duration_range", + tests: [ + { + original: { + name: "from_string_under", + expr: "duration('-320000000000s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: 'duration(\n "-320000000000s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'duration(\n "-320000000000s"~string\n)~duration^string_to_duration', + type: "duration", + }, + { + original: { + name: "from_string_over", + expr: "duration('320000000000s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: 'duration(\n "320000000000s"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'duration(\n "320000000000s"~string\n)~duration^string_to_duration', + type: "duration", + }, + { + original: { + name: "add_under", + expr: "duration('-200000000000s') + duration('-200000000000s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_+_(\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration', + type: "duration", + }, + { + original: { + name: "add_over", + expr: "duration('200000000000s') + duration('200000000000s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_+_(\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n duration(\n "200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "200000000000s"~string\n )~duration^string_to_duration\n)~duration^add_duration_duration', + type: "duration", + }, + { + original: { + name: "sub_under", + expr: "duration('-200000000000s') - duration('200000000000s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_-_(\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_-_(\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "200000000000s"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration', + type: "duration", + }, + { + original: { + name: "sub_over", + expr: "duration('200000000000s') - duration('-200000000000s')", + evalError: { errors: [{ message: "range" }] }, + }, + ast: '_-_(\n duration(\n "200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#,\n duration(\n "-200000000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_-_(\n duration(\n "200000000000s"~string\n )~duration^string_to_duration,\n duration(\n "-200000000000s"~string\n )~duration^string_to_duration\n)~duration^subtract_duration_duration', + type: "duration", + }, + ], + }, + ], + }, + { + name: "type_deductions", + suites: [ + { + name: "constant_literals", + tests: [ + { + original: { + name: "bool", + expr: "true", + typedResult: { + result: { boolValue: true }, + deducedType: { primitive: "BOOL" }, + }, + }, + ast: "true^#*expr.Constant_BoolValue#", + checkedAst: "true~bool", + type: "bool", + }, + { + original: { + name: "int", + expr: "42", + typedResult: { + result: { int64Value: "42" }, + deducedType: { primitive: "INT64" }, + }, + }, + ast: "42^#*expr.Constant_Int64Value#", + checkedAst: "42~int", + type: "int", + }, + { + original: { + name: "uint", + expr: "42u", + typedResult: { + result: { uint64Value: "42" }, + deducedType: { primitive: "UINT64" }, + }, + }, + ast: "42u^#*expr.Constant_Uint64Value#", + checkedAst: "42u~uint", + type: "uint", + }, + { + original: { + name: "double", + expr: "0.1", + typedResult: { + result: { doubleValue: 0.1 }, + deducedType: { primitive: "DOUBLE" }, + }, + }, + ast: "0.1^#*expr.Constant_DoubleValue#", + checkedAst: "0.1~double", + type: "double", + }, + { + original: { + name: "string", + expr: '"test"', + typedResult: { + result: { stringValue: "test" }, + deducedType: { primitive: "STRING" }, + }, + }, + ast: '"test"^#*expr.Constant_StringValue#', + checkedAst: '"test"~string', + type: "string", + }, + { + original: { + name: "bytes", + expr: 'b"test"', + typedResult: { + result: { bytesValue: "dGVzdA==" }, + deducedType: { primitive: "BYTES" }, + }, + }, + ast: 'b"test"^#*expr.Constant_BytesValue#', + checkedAst: 'b"test"~bytes', + type: "bytes", + }, + { + original: { + name: "null", + expr: "null", + typedResult: { + result: { nullValue: null }, + deducedType: { null: null }, + }, + }, + ast: "null^#*expr.Constant_NullValue#", + checkedAst: "null~null", + type: "null", + }, + ], + }, + { + name: "complex_initializers", + tests: [ + { + original: { + name: "list", + expr: "[1]", + typedResult: { + result: { listValue: { values: [{ int64Value: "1" }] } }, + deducedType: { + listType: { elemType: { primitive: "INT64" } }, + }, + }, + }, + ast: "[\n 1^#*expr.Constant_Int64Value#\n]^#*expr.Expr_ListExpr#", + checkedAst: "[\n 1~int\n]~list(int)", + type: "list(int)", + }, + { + original: { + name: "map", + expr: "{'abc': 123}", + typedResult: { + result: { + mapValue: { + entries: [ + { + key: { stringValue: "abc" }, + value: { int64Value: "123" }, + }, + ], + }, + }, + deducedType: { + mapType: { + keyType: { primitive: "STRING" }, + valueType: { primitive: "INT64" }, + }, + }, + }, + }, + ast: '{\n "abc"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#', + checkedAst: '{\n "abc"~string:123~int\n}~map(string, int)', + type: "map(string, int)", + }, + { + original: { + name: "struct", + expr: "TestAllTypes{single_int64: 1}", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + singleInt64: "1", + }, + }, + deducedType: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ast: "TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes", + type: "cel.expr.conformance.proto3.TestAllTypes", + }, + ], + }, + { + name: "field_access", + tests: [ + { + original: { + name: "int_field", + expr: "TestAllTypes{single_int64: 1}.single_int64", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { int64Value: "1" }, + deducedType: { primitive: "INT64" }, + }, + }, + ast: "TestAllTypes{\n single_int64:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_int64:1~int\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_int64~int", + type: "int", + }, + { + original: { + name: "repeated_int_field", + expr: "TestAllTypes{}.repeated_int64", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { listValue: {} }, + deducedType: { + listType: { elemType: { primitive: "INT64" } }, + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_int64~list(int)", + type: "list(int)", + }, + { + original: { + name: "map_bool_int", + expr: "TestAllTypes{}.map_bool_int64", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { mapValue: {} }, + deducedType: { + mapType: { + keyType: { primitive: "BOOL" }, + valueType: { primitive: "INT64" }, + }, + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_bool_int64^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_bool_int64~map(bool, int)", + type: "map(bool, int)", + }, + { + original: { + name: "enum_field", + expr: "TestAllTypes{}.standalone_enum", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { int64Value: "0" }, + deducedType: { primitive: "INT64" }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.standalone_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.standalone_enum~int", + type: "int", + }, + { + original: { + name: "repeated_enum_field", + expr: "TestAllTypes{}.repeated_nested_enum", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { listValue: {} }, + deducedType: { + listType: { elemType: { primitive: "INT64" } }, + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.repeated_nested_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.repeated_nested_enum~list(int)", + type: "list(int)", + }, + { + original: { + name: "enum_map_field", + expr: "TestAllTypes{}.map_int32_enum", + container: "cel.expr.conformance.proto3", + typedResult: { + result: { mapValue: {} }, + deducedType: { + mapType: { + keyType: { primitive: "INT64" }, + valueType: { primitive: "INT64" }, + }, + }, + }, + }, + ast: "TestAllTypes{}^#*expr.Expr_StructExpr#.map_int32_enum^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.map_int32_enum~map(int, int)", + type: "map(int, int)", + }, + ], + }, + { + name: "indexing", + tests: [ + { + original: { + name: "list", + expr: "['foo'][0]", + typedResult: { + result: { stringValue: "foo" }, + deducedType: { primitive: "STRING" }, + }, + }, + ast: '_[_](\n [\n "foo"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n [\n "foo"~string\n ]~list(string),\n 0~int\n)~string^index_list', + type: "string", + }, + { + original: { + name: "map", + expr: "{'abc': 123}['abc']", + typedResult: { + result: { int64Value: "123" }, + deducedType: { primitive: "INT64" }, + }, + }, + ast: '_[_](\n {\n "abc"^#*expr.Constant_StringValue#:123^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n "abc"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_[_](\n {\n "abc"~string:123~int\n }~map(string, int),\n "abc"~string\n)~int^index_map', + type: "int", + }, + ], + }, + { + name: "functions", + tests: [ + { + original: { + name: "nested_calls", + expr: "('foo' + 'bar').startsWith('foo')", + typedResult: { + result: { boolValue: true }, + deducedType: { primitive: "BOOL" }, + }, + }, + ast: '_+_(\n "foo"^#*expr.Constant_StringValue#,\n "bar"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#.startsWith(\n "foo"^#*expr.Constant_StringValue#\n)^#*expr.Expr_CallExpr#', + checkedAst: + '_+_(\n "foo"~string,\n "bar"~string\n)~string^add_string.startsWith(\n "foo"~string\n)~bool^starts_with_string', + type: "bool", + }, + { + original: { + name: "function_result_type", + expr: "fn('abc', 123)", + checkOnly: true, + typeEnv: [ + { + name: "fn", + function: { + overloads: [ + { + overloadId: "fn_string_int", + params: [ + { primitive: "STRING" }, + { primitive: "INT64" }, + ], + resultType: { primitive: "STRING" }, + }, + ], + }, + }, + ], + typedResult: { deducedType: { primitive: "STRING" } }, + }, + ast: 'fn(\n "abc"^#*expr.Constant_StringValue#,\n 123^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#', + checkedAst: + 'fn(\n "abc"~string,\n 123~int\n)~string^fn_string_int', + type: "string", + }, + ], + }, + { + name: "flexible_type_parameter_assignment", + tests: [ + { + original: { + name: "list_parameter", + expr: "[[], [[]], [[[]]], [[[[]]]]]", + checkOnly: true, + typedResult: { + deducedType: { + listType: { + elemType: { + listType: { + elemType: { + listType: { + elemType: { + listType: { + elemType: { + listType: { elemType: { dyn: {} } }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + ast: "[\n []^#*expr.Expr_ListExpr#,\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n []~list(list(list(list(dyn)))),\n [\n []~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))", + type: "list(list(list(list(list(dyn)))))", + }, + { + original: { + name: "list_parameter_order_independent", + expr: "[[[[[]]]], [], [[[]]]]", + checkOnly: true, + typedResult: { + deducedType: { + listType: { + elemType: { + listType: { + elemType: { + listType: { + elemType: { + listType: { + elemType: { + listType: { elemType: { dyn: {} } }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + ast: "[\n [\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#,\n []^#*expr.Expr_ListExpr#,\n [\n [\n []^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n ]^#*expr.Expr_ListExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n [\n [\n [\n []~list(dyn)\n ]~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn)))),\n []~list(list(list(list(dyn)))),\n [\n [\n []~list(list(dyn))\n ]~list(list(list(dyn)))\n ]~list(list(list(list(dyn))))\n]~list(list(list(list(list(dyn)))))", + type: "list(list(list(list(list(dyn)))))", + }, + { + original: { + name: "comprehension_type_var_aliasing", + expr: "msg.repeated_nested_message.map(x, x).map(y, y.bb)", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { + deducedType: { + listType: { elemType: { primitive: "INT64" } }, + }, + }, + }, + ast: "__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n y^#*expr.Expr_IdentExpr#.bb^#*expr.Expr_SelectExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#", + checkedAst: + "__comprehension__(\n // Variable\n y,\n // Target\n __comprehension__(\n // Variable\n x,\n // Target\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result,\n [\n x~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^x\n ]~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n // Result\n @result~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^@result)~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n // Accumulator\n @result,\n // Init\n []~list(int),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(int)^@result,\n [\n y~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^y.bb~int\n ]~list(int)\n )~list(int)^add_list,\n // Result\n @result~list(int)^@result)~list(int)", + type: "list(int)", + }, + { + original: { + name: "overload_type_var_aliasing", + expr: "([] + msg.repeated_nested_message + [])[0].bb", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { deducedType: { primitive: "INT64" } }, + }, + ast: "_[_](\n _+_(\n _+_(\n []^#*expr.Expr_ListExpr#,\n msg^#*expr.Expr_IdentExpr#.repeated_nested_message^#*expr.Expr_SelectExpr#\n )^#*expr.Expr_CallExpr#,\n []^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.bb^#*expr.Expr_SelectExpr#", + checkedAst: + "_[_](\n _+_(\n _+_(\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.repeated_nested_message~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n []~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)\n )~list(cel.expr.conformance.proto3.TestAllTypes.NestedMessage)^add_list,\n 0~int\n)~cel.expr.conformance.proto3.TestAllTypes.NestedMessage^index_list.bb~int", + type: "int", + }, + { + original: { + name: "unconstrained_type_var_as_dyn", + expr: "([].map(x,x))[0].foo", + checkOnly: true, + typedResult: { deducedType: { dyn: {} } }, + }, + ast: "_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []^#*expr.Expr_ListExpr#,\n // Accumulator\n @result,\n // Init\n []^#*expr.Expr_ListExpr#,\n // LoopCondition\n true^#*expr.Constant_BoolValue#,\n // LoopStep\n _+_(\n @result^#*expr.Expr_IdentExpr#,\n [\n x^#*expr.Expr_IdentExpr#\n ]^#*expr.Expr_ListExpr#\n )^#*expr.Expr_CallExpr#,\n // Result\n @result^#*expr.Expr_IdentExpr#)^#*expr.Expr_ComprehensionExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#.foo^#*expr.Expr_SelectExpr#", + checkedAst: + "_[_](\n __comprehension__(\n // Variable\n x,\n // Target\n []~list(dyn),\n // Accumulator\n @result,\n // Init\n []~list(dyn),\n // LoopCondition\n true~bool,\n // LoopStep\n _+_(\n @result~list(dyn)^@result,\n [\n x~dyn^x\n ]~list(dyn)\n )~list(dyn)^add_list,\n // Result\n @result~list(dyn)^@result)~list(dyn),\n 0~int\n)~dyn^index_list.foo~dyn", + type: "dyn", + }, + { + original: { + name: "list_parameters_do_not_unify", + expr: "[msg.single_int64_wrapper, msg.single_string_wrapper]", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { + deducedType: { listType: { elemType: { dyn: {} } } }, + }, + }, + ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_string_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_string_wrapper~wrapper(string)\n]~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "optional_none", + expr: "[optional.none(), optional.of(1)]", + checkOnly: true, + typedResult: { + deducedType: { + listType: { + elemType: { + abstractType: { + name: "optional_type", + parameterTypes: [{ primitive: "INT64" }], + }, + }, + }, + }, + }, + }, + ast: "[\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n optional.none()~optional_type(int)^optional_none,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(int))", + type: "list(optional_type(int))", + }, + { + original: { + name: "optional_none_2", + expr: "[optional.of(1), optional.none()]", + checkOnly: true, + typedResult: { + deducedType: { + listType: { + elemType: { + abstractType: { + name: "optional_type", + parameterTypes: [{ primitive: "INT64" }], + }, + }, + }, + }, + }, + }, + ast: "[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.none()^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.none()~optional_type(int)^optional_none\n]~list(optional_type(int))", + type: "list(optional_type(int))", + }, + { + original: { + name: "optional_dyn_promotion", + expr: "[optional.of(1), optional.of(dyn(1))]", + checkOnly: true, + typedResult: { + deducedType: { + listType: { + elemType: { + abstractType: { + name: "optional_type", + parameterTypes: [{ dyn: {} }], + }, + }, + }, + }, + }, + }, + ast: "[\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of\n]~list(optional_type(dyn))", + type: "list(optional_type(dyn))", + }, + { + original: { + name: "optional_dyn_promotion_2", + expr: "[optional.of(dyn(1)), optional.of(1)]", + checkOnly: true, + typedResult: { + deducedType: { + listType: { + elemType: { + abstractType: { + name: "optional_type", + parameterTypes: [{ dyn: {} }], + }, + }, + }, + }, + }, + }, + ast: "[\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n]~list(optional_type(dyn))", + type: "list(optional_type(dyn))", + }, + { + original: { + name: "optional_in_ternary", + expr: "true ? optional.of(dyn(1)) : optional.of(1)", + checkOnly: true, + typedResult: { + deducedType: { + abstractType: { + name: "optional_type", + parameterTypes: [{ dyn: {} }], + }, + }, + }, + }, + ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n optional^#*expr.Expr_IdentExpr#.of(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#,\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n true~bool,\n optional.of(\n dyn(\n 1~int\n )~dyn^to_dyn\n )~optional_type(dyn)^optional_of,\n optional.of(\n 1~int\n )~optional_type(int)^optional_of\n)~optional_type(dyn)^conditional", + type: "optional_type(dyn)", + }, + ], + }, + { + name: "wrappers", + tests: [ + { + original: { + name: "wrapper_promotion", + expr: "[msg.single_int64_wrapper, msg.single_int64]", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { + deducedType: { listType: { elemType: { wrapper: "INT64" } } }, + }, + }, + ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(wrapper(int))", + type: "list(wrapper(int))", + }, + { + original: { + name: "wrapper_promotion_2", + expr: "[msg.single_int64, msg.single_int64_wrapper]", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { + deducedType: { listType: { elemType: { wrapper: "INT64" } } }, + }, + }, + ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int)\n]~list(int)", + type: "list(int)", + }, + { + original: { + name: "wrapper_dyn_promotion", + expr: "[msg.single_int64_wrapper, msg.single_int64, dyn(1)]", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { + deducedType: { listType: { elemType: { dyn: {} } } }, + }, + }, + ast: "[\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#,\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int,\n dyn(\n 1~int\n )~dyn^to_dyn\n]~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "wrapper_dyn_promotion_2", + expr: "[dyn(1), msg.single_int64_wrapper, msg.single_int64]", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { + deducedType: { listType: { elemType: { dyn: {} } } }, + }, + }, + ast: "[\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n msg^#*expr.Expr_IdentExpr#.single_int64^#*expr.Expr_SelectExpr#\n]^#*expr.Expr_ListExpr#", + checkedAst: + "[\n dyn(\n 1~int\n )~dyn^to_dyn,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64~int\n]~list(dyn)", + type: "list(dyn)", + }, + { + original: { + name: "wrapper_primitive_assignable", + expr: "msg.single_int64_wrapper + 1", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { deducedType: { primitive: "INT64" } }, + }, + ast: "_+_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 1^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_+_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 1~int\n)~int^add_int64", + type: "int", + }, + { + original: { + name: "wrapper_null_assignable", + expr: "msg.single_int64_wrapper == null", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { deducedType: { primitive: "BOOL" } }, + }, + ast: "_==_(\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "wrapper_ternary_parameter_assignment", + expr: "false ? msg.single_int64_wrapper : null", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { deducedType: { wrapper: "INT64" } }, + }, + ast: "_?_:_(\n false^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n false~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n null~null\n)~wrapper(int)^conditional", + type: "wrapper(int)", + }, + { + original: { + name: "wrapper_ternary_parameter_assignment_2", + expr: "true ? msg.single_int64_wrapper : 42", + checkOnly: true, + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + typedResult: { deducedType: { wrapper: "INT64" } }, + }, + ast: "_?_:_(\n true^#*expr.Constant_BoolValue#,\n msg^#*expr.Expr_IdentExpr#.single_int64_wrapper^#*expr.Expr_SelectExpr#,\n 42^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_?_:_(\n true~bool,\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_int64_wrapper~wrapper(int),\n 42~int\n)~wrapper(int)^conditional", + type: "wrapper(int)", + }, + ], + }, + { + name: "type_parameters", + tests: [ + { + original: { + name: "multiple_parameters_generality", + expr: "[tuple(1, 2u, 3.0), tuple(dyn(1), dyn(2u), dyn(3.0))][0]", + checkOnly: true, + typeEnv: [ + { + name: "tuple", + function: { + overloads: [ + { + overloadId: "tuple_T_U_V", + params: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + resultType: { + abstractType: { + name: "tuple", + parameterTypes: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + }, + }, + }, + ], + }, + }, + ], + typedResult: { + deducedType: { + abstractType: { + name: "tuple", + parameterTypes: [{ dyn: {} }, { dyn: {} }, { dyn: {} }], + }, + }, + }, + }, + ast: "_[_](\n [\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(dyn, dyn, dyn)^tuple_T_U_V\n ]~list(tuple(dyn, dyn, dyn)),\n 0~int\n)~tuple(dyn, dyn, dyn)^index_list", + type: "tuple(dyn, dyn, dyn)", + }, + { + original: { + name: "multiple_parameters_generality_2", + expr: "sort(tuple(dyn(1), 2u, 3.0))", + checkOnly: true, + typeEnv: [ + { + name: "tuple", + function: { + overloads: [ + { + overloadId: "tuple_T_U_V", + params: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + resultType: { + abstractType: { + name: "tuple", + parameterTypes: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + }, + }, + }, + ], + }, + }, + { + name: "sort", + function: { + overloads: [ + { + overloadId: "sort_tuple_T_T_T", + params: [ + { + abstractType: { + name: "tuple", + parameterTypes: [ + { typeParam: "T" }, + { typeParam: "T" }, + { typeParam: "T" }, + ], + }, + }, + ], + resultType: { + abstractType: { + name: "tuple", + parameterTypes: [ + { typeParam: "T" }, + { typeParam: "T" }, + { typeParam: "T" }, + ], + }, + }, + }, + ], + }, + }, + ], + typedResult: { + deducedType: { + abstractType: { + name: "tuple", + parameterTypes: [{ dyn: {} }, { dyn: {} }, { dyn: {} }], + }, + }, + }, + }, + ast: "sort(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "sort(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n 2u~uint,\n 3~double\n )~tuple(dyn, uint, double)^tuple_T_U_V\n)~tuple(dyn, dyn, dyn)^sort_tuple_T_T_T", + type: "tuple(dyn, dyn, dyn)", + }, + { + original: { + name: "multiple_parameters_parameterized_ovl", + expr: "tuple(1, 2u, 3.0) == tuple(1, dyn(2u), dyn(3.0))", + checkOnly: true, + typeEnv: [ + { + name: "tuple", + function: { + overloads: [ + { + overloadId: "tuple_T_U_V", + params: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + resultType: { + abstractType: { + name: "tuple", + parameterTypes: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + }, + }, + }, + ], + }, + }, + ], + typedResult: { deducedType: { primitive: "BOOL" } }, + }, + ast: "_==_(\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V,\n tuple(\n 1~int,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n dyn(\n 3~double\n )~dyn^to_dyn\n )~tuple(int, dyn, dyn)^tuple_T_U_V\n)~bool^equals", + type: "bool", + }, + { + original: { + name: "multiple_parameters_parameterized_ovl_2", + expr: "tuple(dyn(1), dyn(2u), 3.0) == tuple(1, 2u, 3.0)", + checkOnly: true, + typeEnv: [ + { + name: "tuple", + function: { + overloads: [ + { + overloadId: "tuple_T_U_V", + params: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + resultType: { + abstractType: { + name: "tuple", + parameterTypes: [ + { typeParam: "T" }, + { typeParam: "U" }, + { typeParam: "V" }, + ], + }, + }, + }, + ], + }, + }, + ], + typedResult: { deducedType: { primitive: "BOOL" } }, + }, + ast: "_==_(\n tuple(\n dyn(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n dyn(\n 2u^#*expr.Constant_Uint64Value#\n )^#*expr.Expr_CallExpr#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#,\n tuple(\n 1^#*expr.Constant_Int64Value#,\n 2u^#*expr.Constant_Uint64Value#,\n 3^#*expr.Constant_DoubleValue#\n )^#*expr.Expr_CallExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n tuple(\n dyn(\n 1~int\n )~dyn^to_dyn,\n dyn(\n 2u~uint\n )~dyn^to_dyn,\n 3~double\n )~tuple(dyn, dyn, double)^tuple_T_U_V,\n tuple(\n 1~int,\n 2u~uint,\n 3~double\n )~tuple(int, uint, double)^tuple_T_U_V\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "legacy_nullable_types", + tests: [ + { + original: { + name: "null_assignable_to_message_parameter_candidate", + expr: "[msg, null][0]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + }, + typedResult: { + result: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + }, + }, + deducedType: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ast: "_[_](\n [\n msg^#*expr.Expr_IdentExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", + type: "null", + }, + { + original: { + name: "null_assignable_to_duration_parameter_candidate", + expr: "[msg.single_duration, null][0]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + }, + typedResult: { + result: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Duration", + value: "0s", + }, + }, + deducedType: { wellKnown: "DURATION" }, + }, + }, + ast: "_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_duration^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_duration~duration,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", + type: "null", + }, + { + original: { + name: "null_assignable_to_timestamp_parameter_candidate", + expr: "[msg.single_timestamp, null][0]", + typeEnv: [ + { + name: "msg", + ident: { + type: { + messageType: "cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + ], + bindings: { + msg: { + value: { + objectValue: { + "@type": + "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes", + }, + }, + }, + }, + typedResult: { + result: { + objectValue: { + "@type": "type.googleapis.com/google.protobuf.Timestamp", + value: "1970-01-01T00:00:00Z", + }, + }, + deducedType: { wellKnown: "TIMESTAMP" }, + }, + }, + ast: "_[_](\n [\n msg^#*expr.Expr_IdentExpr#.single_timestamp^#*expr.Expr_SelectExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n msg~cel.expr.conformance.proto3.TestAllTypes^msg.single_timestamp~timestamp,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", + type: "null", + }, + { + original: { + name: "null_assignable_to_abstract_parameter_candidate", + expr: "[optional.of(1), null][0]", + checkOnly: true, + typedResult: { + deducedType: { + abstractType: { + name: "optional_type", + parameterTypes: [{ primitive: "INT64" }], + }, + }, + }, + }, + ast: "_[_](\n [\n optional^#*expr.Expr_IdentExpr#.of(\n 1^#*expr.Constant_Int64Value#\n )^#*expr.Expr_CallExpr#,\n null^#*expr.Constant_NullValue#\n ]^#*expr.Expr_ListExpr#,\n 0^#*expr.Constant_Int64Value#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_[_](\n [\n optional.of(\n 1~int\n )~optional_type(int)^optional_of,\n null~null\n ]~list(null),\n 0~int\n)~null^index_list", + type: "null", + }, + ], + }, + ], + }, + { name: "unknowns" }, + { + name: "wrappers", + suites: [ + { + name: "bool", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.BoolValue{value: true}}.single_any", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.BoolValue{value: true}}.single_value", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true^#*expr.Constant_BoolValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BoolValue{\n value:true~bool\n }~wrapper(bool)^google.protobuf.BoolValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_bool_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_bool_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bool_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "int32", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.Int32Value{value: 1}}.single_any", + container: "cel.expr.conformance.proto3", + value: { int64Value: "1" }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.Int32Value{value: 1}}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int32Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_int32_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_int32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "int64", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.Int64Value{value: 1}}.single_any", + container: "cel.expr.conformance.proto3", + value: { int64Value: "1" }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json_number", + expr: "TestAllTypes{single_value: google.protobuf.Int64Value{value: 1}}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:1~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_json_string", + expr: "TestAllTypes{single_value: google.protobuf.Int64Value{value: 9223372036854775807}}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "9223372036854775807" }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807^#*expr.Constant_Int64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Int64Value{\n value:9223372036854775807~int\n }~wrapper(int)^google.protobuf.Int64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_int64_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_int64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_int64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "uint32", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.UInt32Value{value: 1u}}.single_any", + container: "cel.expr.conformance.proto3", + value: { uint64Value: "1" }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.UInt32Value{value: 1u}}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt32Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt32Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_uint32_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_uint32_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint32_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "uint64", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.UInt64Value{value: 1u}}.single_any", + container: "cel.expr.conformance.proto3", + value: { uint64Value: "1" }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json_number", + expr: "TestAllTypes{single_value: google.protobuf.UInt64Value{value: 1u}}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:1u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_json_string", + expr: "TestAllTypes{single_value: google.protobuf.UInt64Value{value: 18446744073709551615u}}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "18446744073709551615" }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u^#*expr.Constant_Uint64Value#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.UInt64Value{\n value:18446744073709551615u~uint\n }~wrapper(uint)^google.protobuf.UInt64Value\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_uint64_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_uint64_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_uint64_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "float", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.FloatValue{value: 1.0}}.single_any", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.FloatValue{value: 1.0}}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FloatValue{\n value:1~double\n }~wrapper(double)^google.protobuf.FloatValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_float_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_float_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_float_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "double", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.DoubleValue{value: 1.0}}.single_any", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.DoubleValue{value: 1.0}}.single_value", + container: "cel.expr.conformance.proto3", + value: { doubleValue: 1 }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1^#*expr.Constant_DoubleValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.DoubleValue{\n value:1~double\n }~wrapper(double)^google.protobuf.DoubleValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_double_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_double_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_double_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "bytes", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.BytesValue{value: b'foo'}}.single_any", + container: "cel.expr.conformance.proto3", + value: { bytesValue: "Zm9v" }, + }, + ast: 'TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b"foo"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.BytesValue{\n value:b"foo"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any', + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.BytesValue{value: b'foo'}}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "Zm9v" }, + }, + ast: 'TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b"foo"^#*expr.Constant_BytesValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.BytesValue{\n value:b"foo"~bytes\n }~wrapper(bytes)^google.protobuf.BytesValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_bytes_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_bytes_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_bytes_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "string", + tests: [ + { + original: { + name: "to_any", + expr: "TestAllTypes{single_any: google.protobuf.StringValue{value: 'foo'}}.single_any", + container: "cel.expr.conformance.proto3", + value: { stringValue: "foo" }, + }, + ast: 'TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_any:google.protobuf.StringValue{\n value:"foo"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any', + type: "any", + }, + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.StringValue{value: 'foo'}}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "foo" }, + }, + ast: 'TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:"foo"^#*expr.Constant_StringValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.StringValue{\n value:"foo"~string\n }~wrapper(string)^google.protobuf.StringValue\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + { + original: { + name: "to_null", + expr: "TestAllTypes{single_string_wrapper: null} == TestAllTypes{}", + container: "cel.expr.conformance.proto3", + value: { boolValue: true }, + }, + ast: "_==_(\n TestAllTypes{\n single_string_wrapper:null^#*expr.Constant_NullValue#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#,\n TestAllTypes{}^#*expr.Expr_StructExpr#\n)^#*expr.Expr_CallExpr#", + checkedAst: + "_==_(\n cel.expr.conformance.proto3.TestAllTypes{\n single_string_wrapper:null~null\n }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes,\n cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes\n)~bool^equals", + type: "bool", + }, + ], + }, + { + name: "value", + tests: [ + { + original: { + name: "default_to_json", + expr: "TestAllTypes{single_any: TestAllTypes{}.single_value}.single_any", + container: "cel.expr.conformance.proto3", + value: { nullValue: null }, + }, + ast: "TestAllTypes{\n single_any:TestAllTypes{}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + ], + }, + { + name: "list_value", + tests: [ + { + original: { + name: "literal_to_any", + expr: "TestAllTypes{single_any: []}.single_any", + container: "cel.expr.conformance.proto3", + value: { listValue: {} }, + }, + ast: "TestAllTypes{\n single_any:[]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:[]~list(dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + ], + }, + { + name: "struct", + tests: [ + { + original: { + name: "literal_to_any", + expr: "TestAllTypes{single_any: {}}.single_any", + container: "cel.expr.conformance.proto3", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{\n single_any:{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_any^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_any:{}~map(dyn, dyn)\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_any~any", + type: "any", + }, + ], + }, + { + name: "field_mask", + tests: [ + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.FieldMask{paths: ['foo', 'bar']}}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "foo,bar" }, + }, + ast: 'TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n "foo"^#*expr.Constant_StringValue#,\n "bar"^#*expr.Constant_StringValue#\n ]^#*expr.Expr_ListExpr#^#*expr.Expr_CreateStruct_Entry#\n }^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.FieldMask{\n paths:[\n "foo"~string,\n "bar"~string\n ]~list(string)\n }~google.protobuf.FieldMask^google.protobuf.FieldMask\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + ], + }, + { + name: "duration", + tests: [ + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: duration('1000000s')}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "1000000s" }, + }, + ast: 'TestAllTypes{\n single_value:duration(\n "1000000s"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:duration(\n "1000000s"~string\n )~duration^string_to_duration\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + ], + }, + { + name: "timestamp", + tests: [ + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: timestamp('9999-12-31T23:59:59.999999999Z')}.single_value", + container: "cel.expr.conformance.proto3", + value: { stringValue: "9999-12-31T23:59:59.999999999Z" }, + }, + ast: 'TestAllTypes{\n single_value:timestamp(\n "9999-12-31T23:59:59.999999999Z"^#*expr.Constant_StringValue#\n )^#*expr.Expr_CallExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#', + checkedAst: + 'cel.expr.conformance.proto3.TestAllTypes{\n single_value:timestamp(\n "9999-12-31T23:59:59.999999999Z"~string\n )~timestamp^string_to_timestamp\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn', + type: "dyn", + }, + ], + }, + { + name: "empty", + tests: [ + { + original: { + name: "to_json", + expr: "TestAllTypes{single_value: google.protobuf.Empty{}}.single_value", + container: "cel.expr.conformance.proto3", + value: { mapValue: {} }, + }, + ast: "TestAllTypes{\n single_value:google.protobuf.Empty{}^#*expr.Expr_StructExpr#^#*expr.Expr_CreateStruct_Entry#\n}^#*expr.Expr_StructExpr#.single_value^#*expr.Expr_SelectExpr#", + checkedAst: + "cel.expr.conformance.proto3.TestAllTypes{\n single_value:google.protobuf.Empty{}~google.protobuf.Empty^google.protobuf.Empty\n}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn", + type: "dyn", + }, + ], + }, + ], + }, + ], +} as const; diff --git a/packages/cel/package-lock.json b/packages/cel/package-lock.json deleted file mode 100644 index 1ef2333..0000000 --- a/packages/cel/package-lock.json +++ /dev/null @@ -1,270 +0,0 @@ -{ - "name": "@bufbuild/cel", - "version": "0.4.0", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "@bufbuild/cel", - "version": "0.4.0", - "license": "Apache-2.0", - "dependencies": { - "@bufbuild/cel-spec": "0.4.0" - }, - "devDependencies": { - "@unicode/unicode-16.0.0": "^1.6.16", - "expect-type": "^1.3.0", - "peggy": "^5.0.6", - "peggy-ts": "github:hudlow/peggy-ts#v0.0.9", - "unicode-property-value-aliases": "^3.9.0" - }, - "peerDependencies": { - "@bufbuild/protobuf": "^2.6.2" - } - }, - "node_modules/@bufbuild/cel-spec": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/@bufbuild/cel-spec/-/cel-spec-0.4.0.tgz", - "integrity": "sha512-dUS6f2fNt6KEumsYGE7YFxERZE5ZuyME1hQmGjtO8tkZhR6ow6/ne3v4Gik9cfdb9lSLK3AJ+vDxCdGWmDbWvA==", - "license": "Apache-2.0", - "peerDependencies": { - "@bufbuild/protobuf": "^2.6.2" - } - }, - "node_modules/@bufbuild/protobuf": { - "version": "2.11.0", - "resolved": "https://registry.npmjs.org/@bufbuild/protobuf/-/protobuf-2.11.0.tgz", - "integrity": "sha512-sBXGT13cpmPR5BMgHE6UEEfEaShh5Ror6rfN3yEK5si7QVrtZg8LEPQb0VVhiLRUslD2yLnXtnRzG035J/mZXQ==", - "license": "(Apache-2.0 AND BSD-3-Clause)", - "peer": true - }, - "node_modules/@peggyjs/from-mem": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/@peggyjs/from-mem/-/from-mem-3.1.3.tgz", - "integrity": "sha512-LLlgtfXIaeYXoOYovOI0spLM8ZXaqkAlmcRRrLzHJzLMqkU6Sw0R4KMoCoHx1PjaP815pSCBlS+BN6aD8t1Jgg==", - "dev": true, - "license": "MIT", - "dependencies": { - "semver": "7.7.4" - }, - "engines": { - "node": ">=20.8" - } - }, - "node_modules/@ts-morph/common": { - "version": "0.28.1", - "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.28.1.tgz", - "integrity": "sha512-W74iWf7ILp1ZKNYXY5qbddNaml7e9Sedv5lvU1V8lftlitkc9Pq1A+jlH23ltDgWYeZFFEqGCD1Ies9hqu3O+g==", - "dev": true, - "license": "MIT", - "dependencies": { - "minimatch": "^10.0.1", - "path-browserify": "^1.0.1", - "tinyglobby": "^0.2.14" - } - }, - "node_modules/@unicode/unicode-16.0.0": { - "version": "1.6.16", - "resolved": "https://registry.npmjs.org/@unicode/unicode-16.0.0/-/unicode-16.0.0-1.6.16.tgz", - "integrity": "sha512-R2Vxi0XEsCMD9WOQT85O2npa7g+i4RsJ8Xtn+/KODLqa5wH5zCTn5an6JILJhMSfFGD3t3amES2XnvUHnKjMZQ==", - "dev": true, - "license": "MIT" - }, - "node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "node_modules/brace-expansion": { - "version": "5.0.5", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz", - "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "node_modules/code-block-writer": { - "version": "13.0.3", - "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-13.0.3.tgz", - "integrity": "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==", - "dev": true, - "license": "MIT" - }, - "node_modules/commander": { - "version": "14.0.3", - "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz", - "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=20" - } - }, - "node_modules/expect-type": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", - "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", - "dev": true, - "license": "Apache-2.0", - "engines": { - "node": ">=12.0.0" - } - }, - "node_modules/fdir": { - "version": "6.5.0", - "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", - "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12.0.0" - }, - "peerDependencies": { - "picomatch": "^3 || ^4" - }, - "peerDependenciesMeta": { - "picomatch": { - "optional": true - } - } - }, - "node_modules/minimatch": { - "version": "10.2.5", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", - "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.5" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/path-browserify": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", - "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==", - "dev": true, - "license": "MIT" - }, - "node_modules/peggy": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/peggy/-/peggy-5.1.0.tgz", - "integrity": "sha512-IEo5aYRZ2kXH4Qby06cjtL114PZnwLoTiA41vUmg2vPZgANn+c87m5BUurhuDr5/cu758ZlpgsAfBVx+hhO5+w==", - "dev": true, - "license": "MIT", - "dependencies": { - "@peggyjs/from-mem": "3.1.3", - "commander": "^14.0.3", - "source-map-generator": "2.0.6" - }, - "bin": { - "peggy": "bin/peggy.js" - }, - "engines": { - "node": ">=20" - } - }, - "node_modules/peggy-ts": { - "version": "0.0.9", - "resolved": "git+ssh://git@github.com/hudlow/peggy-ts.git#9adcea0eadb89bea93cc6bece8a429e00df044e8", - "dev": true, - "license": "Apache-2.0", - "dependencies": { - "source-map-generator": "^2.0.2", - "ts-morph": "^27.0.2" - }, - "peerDependencies": { - "peggy": "^5.0.6" - } - }, - "node_modules/picomatch": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", - "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } - }, - "node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/source-map-generator": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/source-map-generator/-/source-map-generator-2.0.6.tgz", - "integrity": "sha512-IlassDs1Ve8nV6uyQZXF9kdkJpVKnMte2JZQXu13M0A5zwc+vu6+LNHfmxsHBMDtoZE21RHiKI0/xvpecZRCNg==", - "dev": true, - "license": "BSD-3-Clause", - "engines": { - "node": ">=20" - } - }, - "node_modules/tinyglobby": { - "version": "0.2.16", - "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz", - "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", - "dev": true, - "license": "MIT", - "dependencies": { - "fdir": "^6.5.0", - "picomatch": "^4.0.4" - }, - "engines": { - "node": ">=12.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/SuperchupuDev" - } - }, - "node_modules/ts-morph": { - "version": "27.0.2", - "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-27.0.2.tgz", - "integrity": "sha512-fhUhgeljcrdZ+9DZND1De1029PrE+cMkIP7ooqkLRTrRLTqcki2AstsyJm0vRNbTbVCNJ0idGlbBrfqc7/nA8w==", - "dev": true, - "license": "MIT", - "dependencies": { - "@ts-morph/common": "~0.28.1", - "code-block-writer": "^13.0.3" - } - }, - "node_modules/unicode-property-value-aliases": { - "version": "3.9.0", - "resolved": "https://registry.npmjs.org/unicode-property-value-aliases/-/unicode-property-value-aliases-3.9.0.tgz", - "integrity": "sha512-UFsQgFziRAXuFS9hN48PnwujNFwsuRWHj+bd840X7aYC1xa0MHlKsaxzapp5lM4C4HuAPko5cFiTUydeQ428Bg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - } - } -} diff --git a/packages/cel/package.json b/packages/cel/package.json index 1362871..1eaeaab 100644 --- a/packages/cel/package.json +++ b/packages/cel/package.json @@ -18,7 +18,7 @@ "scripts": { "generate": "cd ./src && peggy cel.peggy --format bare --extra-options '{\"typescript\":true}' --plugin peggy-ts -o parser.ts", "postgenerate": "biome format src/parser.ts --write", - "test": "npx tsx --test ./src/*.test.ts ./src/*/*.test.ts ./src/re2/__tests__/*.test.ts", + "test": "npx tsx --test ./src/*.test.ts ./src/*/*.test.ts", "prebuild": "rm -rf ./dist/*", "build": "npm run build:cjs && npm run build:esm", "build:cjs": "tsc --project tsconfig.json --module commonjs --verbatimModuleSyntax false --moduleResolution node10 --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'", @@ -53,7 +53,8 @@ "@bufbuild/protobuf": "^2.6.2" }, "dependencies": { - "@bufbuild/cel-spec": "0.4.0" + "@bufbuild/cel-spec": "0.4.0", + "@bufbuild/re2": "0.4.0" }, "devDependencies": { "@unicode/unicode-16.0.0": "^1.6.16", diff --git a/packages/cel/src/std/logic.ts b/packages/cel/src/std/logic.ts index 122926b..f30ebb0 100644 --- a/packages/cel/src/std/logic.ts +++ b/packages/cel/src/std/logic.ts @@ -26,7 +26,7 @@ import {equals} from "../equals.js"; import {celMethod, celFunc} from "../func.js"; import type {CelList} from "../list.js"; import type {CelMap} from "../map.js"; -import {RE2JS} from "../re2/index.js"; +import {RE2JS} from "@bufbuild/re2"; /** * Patterns that are supported in ECMAScript RE and not in diff --git a/packages/cel/tsconfig.json b/packages/cel/tsconfig.json index 5dcff4f..3ae4550 100644 --- a/packages/cel/tsconfig.json +++ b/packages/cel/tsconfig.json @@ -2,9 +2,4 @@ "files": ["src/index.ts", "src/ext/index.ts"], "extends": "../../tsconfig.base.json", "include": ["src/**/*.test.ts"], - "exclude": [ - "src/re2/__tests__", - "src/re2/__fixtures__", - "src/re2/__utils__" - ] } diff --git a/packages/re2/.npmignore b/packages/re2/.npmignore new file mode 100644 index 0000000..369e762 --- /dev/null +++ b/packages/re2/.npmignore @@ -0,0 +1,10 @@ +src +scripts +tsconfig.json +tsconfig.*.json +turbo.json +biome.json +dist/**/*.test.js +dist/**/*.test.d.ts +dist/*/testing.js +dist/*/testing.d.ts diff --git a/packages/re2/LICENSE b/packages/re2/LICENSE new file mode 100644 index 0000000..4fc0dfc --- /dev/null +++ b/packages/re2/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Alexey Vasiliev + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/re2/README.md b/packages/re2/README.md new file mode 100644 index 0000000..0301684 --- /dev/null +++ b/packages/re2/README.md @@ -0,0 +1,30 @@ +# @bufbuild/re2 + +This package provides an [RE2-compatible](https://cel.dev) regular expression engine, designed for use with CEL-es and Protovalidate-es. + +## Usage + +```ts +import { RE2JS } from '@bufbuild/re2'; + +const re = new RE2JS('^foo'); +console.log(re.test('foo')); // true +console.log(re.testExact('fooxyz')); // false + +console.log(RE2JS.matches('^foo','foo')); // true +``` + +## Limitations +Only boolean matchers are supported: `test` and `testExact`. + +The instance method `matches` is an alias for `testExact`. The static method `RE2JS.matches` compiles +a regular expression and calls `testExact`. + +As a size optimization, Unicode category and script information is generated on first use. This causes a +slight slowdown the first time a pattern is compiled with a category or script (only the referenced category +or script is generated). The categories and scripts in Unicode version 16.0 are supported. This package includes +data to support Unicode version 16.0 on Unicode 15.0 or later. + +## Credits +This code is a fork of the [RE2JS](https://re2js.leopard.in.ua) project. It has been converted to TypeScript and has a feature set tailored for +CEL and Protovalidate-es. \ No newline at end of file diff --git a/packages/re2/biome.json b/packages/re2/biome.json new file mode 100644 index 0000000..4ce16bd --- /dev/null +++ b/packages/re2/biome.json @@ -0,0 +1,14 @@ +{ + "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json", + "extends": ["../../biome.base.json"], + "formatter": { + "ignore": ["dist", "src/gen"] + }, + "linter": { + "rules": { + "suspicious": { + "noControlCharactersInRegex": "off" + } + } + } +} diff --git a/packages/re2/package.json b/packages/re2/package.json new file mode 100644 index 0000000..fcd2308 --- /dev/null +++ b/packages/re2/package.json @@ -0,0 +1,48 @@ +{ + "name": "@bufbuild/re2", + "version": "0.4.0", + "description": "An RE2-compatible regex engine tailored for CEL and Protovalidate", + "keywords": [ + "javascript", + "typescript", + "protobuf", + "cel", + "common-expression-language" + ], + "license": "MIT", + "repository": { + "type": "git", + "url": "git+https://github.com/bufbuild/cel-es.git", + "directory": "packages/re2" + }, + "scripts": { + "test": "npx tsx --test ./src/__tests__/*.test.ts", + "prebuild": "rm -rf ./dist/*", + "build": "npm run build:cjs && npm run build:esm", + "build:cjs": "tsc --project tsconfig.json --module commonjs --verbatimModuleSyntax false --moduleResolution node10 --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'", + "build:esm": "tsc --project tsconfig.json --outDir ./dist/esm", + "format": "biome format --write", + "lint": "biome lint --error-on-warnings", + "attw": "attw --pack", + "license-header": "license-header" + }, + "licenseHeader": { + "licenseType": "MIT", + "yearRange": "2023-2026", + "copyrightHolder": "Alexey Vasiliev and Buf Technologies, Inc." + }, + "type": "module", + "sideEffects": false, + "main": "./dist/cjs/index.js", + "types": "./dist/cjs/index.d.ts", + "exports": { + ".": { + "import": "./dist/esm/index.js", + "require": "./dist/cjs/index.js" + } + }, + "devDependencies": { + "@unicode/unicode-16.0.0": "^1.6.16", + "unicode-property-value-aliases": "^3.9.0" + } +} diff --git a/scripts/codepointRange.js b/packages/re2/scripts/codepointRange.js similarity index 100% rename from scripts/codepointRange.js rename to packages/re2/scripts/codepointRange.js diff --git a/scripts/genUnicodeTable.js b/packages/re2/scripts/genUnicodeTable.js similarity index 100% rename from scripts/genUnicodeTable.js rename to packages/re2/scripts/genUnicodeTable.js diff --git a/scripts/make_perl_groups.pl b/packages/re2/scripts/make_perl_groups.pl similarity index 100% rename from scripts/make_perl_groups.pl rename to packages/re2/scripts/make_perl_groups.pl diff --git a/packages/cel/src/re2/CharClass.ts b/packages/re2/src/CharClass.ts similarity index 100% rename from packages/cel/src/re2/CharClass.ts rename to packages/re2/src/CharClass.ts diff --git a/packages/cel/src/re2/CharGroup.ts b/packages/re2/src/CharGroup.ts similarity index 100% rename from packages/cel/src/re2/CharGroup.ts rename to packages/re2/src/CharGroup.ts diff --git a/packages/cel/src/re2/Codepoint.ts b/packages/re2/src/Codepoint.ts similarity index 100% rename from packages/cel/src/re2/Codepoint.ts rename to packages/re2/src/Codepoint.ts diff --git a/packages/cel/src/re2/Compiler.ts b/packages/re2/src/Compiler.ts similarity index 100% rename from packages/cel/src/re2/Compiler.ts rename to packages/re2/src/Compiler.ts diff --git a/packages/cel/src/re2/DFA.ts b/packages/re2/src/DFA.ts similarity index 100% rename from packages/cel/src/re2/DFA.ts rename to packages/re2/src/DFA.ts diff --git a/packages/cel/src/re2/Inst.ts b/packages/re2/src/Inst.ts similarity index 100% rename from packages/cel/src/re2/Inst.ts rename to packages/re2/src/Inst.ts diff --git a/packages/cel/src/re2/MachineInput.ts b/packages/re2/src/MachineInput.ts similarity index 100% rename from packages/cel/src/re2/MachineInput.ts rename to packages/re2/src/MachineInput.ts diff --git a/packages/cel/src/re2/Parser.ts b/packages/re2/src/Parser.ts similarity index 100% rename from packages/cel/src/re2/Parser.ts rename to packages/re2/src/Parser.ts diff --git a/packages/cel/src/re2/Prefilter.ts b/packages/re2/src/Prefilter.ts similarity index 100% rename from packages/cel/src/re2/Prefilter.ts rename to packages/re2/src/Prefilter.ts diff --git a/packages/cel/src/re2/Prog.ts b/packages/re2/src/Prog.ts similarity index 100% rename from packages/cel/src/re2/Prog.ts rename to packages/re2/src/Prog.ts diff --git a/packages/cel/src/re2/RE2.ts b/packages/re2/src/RE2.ts similarity index 100% rename from packages/cel/src/re2/RE2.ts rename to packages/re2/src/RE2.ts diff --git a/packages/cel/src/re2/RE2Flags.ts b/packages/re2/src/RE2Flags.ts similarity index 100% rename from packages/cel/src/re2/RE2Flags.ts rename to packages/re2/src/RE2Flags.ts diff --git a/packages/cel/src/re2/Regexp.ts b/packages/re2/src/Regexp.ts similarity index 100% rename from packages/cel/src/re2/Regexp.ts rename to packages/re2/src/Regexp.ts diff --git a/packages/cel/src/re2/Simplify.ts b/packages/re2/src/Simplify.ts similarity index 100% rename from packages/cel/src/re2/Simplify.ts rename to packages/re2/src/Simplify.ts diff --git a/packages/cel/src/re2/Unicode.ts b/packages/re2/src/Unicode.ts similarity index 100% rename from packages/cel/src/re2/Unicode.ts rename to packages/re2/src/Unicode.ts diff --git a/packages/cel/src/re2/UnicodeRangeTable.ts b/packages/re2/src/UnicodeRangeTable.ts similarity index 100% rename from packages/cel/src/re2/UnicodeRangeTable.ts rename to packages/re2/src/UnicodeRangeTable.ts diff --git a/packages/cel/src/re2/UnicodeTables.ts b/packages/re2/src/UnicodeTables.ts similarity index 100% rename from packages/cel/src/re2/UnicodeTables.ts rename to packages/re2/src/UnicodeTables.ts diff --git a/packages/cel/src/re2/Utils.ts b/packages/re2/src/Utils.ts similarity index 100% rename from packages/cel/src/re2/Utils.ts rename to packages/re2/src/Utils.ts diff --git a/packages/cel/src/re2/__fixtures__/basic.dat b/packages/re2/src/__fixtures__/basic.dat similarity index 100% rename from packages/cel/src/re2/__fixtures__/basic.dat rename to packages/re2/src/__fixtures__/basic.dat diff --git a/packages/cel/src/re2/__fixtures__/find.ts b/packages/re2/src/__fixtures__/find.ts similarity index 100% rename from packages/cel/src/re2/__fixtures__/find.ts rename to packages/re2/src/__fixtures__/find.ts diff --git a/packages/cel/src/re2/__fixtures__/nullsubexpr.dat b/packages/re2/src/__fixtures__/nullsubexpr.dat similarity index 100% rename from packages/cel/src/re2/__fixtures__/nullsubexpr.dat rename to packages/re2/src/__fixtures__/nullsubexpr.dat diff --git a/packages/cel/src/re2/__fixtures__/re2-exhaustive.txt.gz b/packages/re2/src/__fixtures__/re2-exhaustive.txt.gz similarity index 100% rename from packages/cel/src/re2/__fixtures__/re2-exhaustive.txt.gz rename to packages/re2/src/__fixtures__/re2-exhaustive.txt.gz diff --git a/packages/cel/src/re2/__fixtures__/re2-search.txt b/packages/re2/src/__fixtures__/re2-search.txt similarity index 100% rename from packages/cel/src/re2/__fixtures__/re2-search.txt rename to packages/re2/src/__fixtures__/re2-search.txt diff --git a/packages/cel/src/re2/__fixtures__/repetition.dat b/packages/re2/src/__fixtures__/repetition.dat similarity index 100% rename from packages/cel/src/re2/__fixtures__/repetition.dat rename to packages/re2/src/__fixtures__/repetition.dat diff --git a/packages/cel/src/re2/__tests__/BugHunt.test.ts b/packages/re2/src/__tests__/BugHunt.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/BugHunt.test.ts rename to packages/re2/src/__tests__/BugHunt.test.ts diff --git a/packages/cel/src/re2/__tests__/CharClass.test.ts b/packages/re2/src/__tests__/CharClass.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/CharClass.test.ts rename to packages/re2/src/__tests__/CharClass.test.ts diff --git a/packages/cel/src/re2/__tests__/Codepoint.test.ts b/packages/re2/src/__tests__/Codepoint.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/Codepoint.test.ts rename to packages/re2/src/__tests__/Codepoint.test.ts diff --git a/packages/cel/src/re2/__tests__/DFA.test.ts b/packages/re2/src/__tests__/DFA.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/DFA.test.ts rename to packages/re2/src/__tests__/DFA.test.ts diff --git a/packages/cel/src/re2/__tests__/Exec.test.ts b/packages/re2/src/__tests__/Exec.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/Exec.test.ts rename to packages/re2/src/__tests__/Exec.test.ts diff --git a/packages/cel/src/re2/__tests__/Inst.test.ts b/packages/re2/src/__tests__/Inst.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/Inst.test.ts rename to packages/re2/src/__tests__/Inst.test.ts diff --git a/packages/cel/src/re2/__tests__/Parser.test.ts b/packages/re2/src/__tests__/Parser.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/Parser.test.ts rename to packages/re2/src/__tests__/Parser.test.ts diff --git a/packages/cel/src/re2/__tests__/Prefilter.test.ts b/packages/re2/src/__tests__/Prefilter.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/Prefilter.test.ts rename to packages/re2/src/__tests__/Prefilter.test.ts diff --git a/packages/cel/src/re2/__tests__/RE2Compile.test.ts b/packages/re2/src/__tests__/RE2Compile.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/RE2Compile.test.ts rename to packages/re2/src/__tests__/RE2Compile.test.ts diff --git a/packages/cel/src/re2/__tests__/RE2ExecuteEngine.test.ts b/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/RE2ExecuteEngine.test.ts rename to packages/re2/src/__tests__/RE2ExecuteEngine.test.ts diff --git a/packages/cel/src/re2/__tests__/RE2Match.test.ts b/packages/re2/src/__tests__/RE2Match.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/RE2Match.test.ts rename to packages/re2/src/__tests__/RE2Match.test.ts diff --git a/packages/cel/src/re2/__tests__/RE2QuoteMeta.test.ts b/packages/re2/src/__tests__/RE2QuoteMeta.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/RE2QuoteMeta.test.ts rename to packages/re2/src/__tests__/RE2QuoteMeta.test.ts diff --git a/packages/cel/src/re2/__tests__/StressBoundary.test.ts b/packages/re2/src/__tests__/StressBoundary.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/StressBoundary.test.ts rename to packages/re2/src/__tests__/StressBoundary.test.ts diff --git a/packages/cel/src/re2/__tests__/StressErrorRecovery.test.ts b/packages/re2/src/__tests__/StressErrorRecovery.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/StressErrorRecovery.test.ts rename to packages/re2/src/__tests__/StressErrorRecovery.test.ts diff --git a/packages/cel/src/re2/__tests__/StressFlags.test.ts b/packages/re2/src/__tests__/StressFlags.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/StressFlags.test.ts rename to packages/re2/src/__tests__/StressFlags.test.ts diff --git a/packages/cel/src/re2/__tests__/StressUnicode.test.ts b/packages/re2/src/__tests__/StressUnicode.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/StressUnicode.test.ts rename to packages/re2/src/__tests__/StressUnicode.test.ts diff --git a/packages/cel/src/re2/__tests__/Unicode.test.ts b/packages/re2/src/__tests__/Unicode.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/Unicode.test.ts rename to packages/re2/src/__tests__/Unicode.test.ts diff --git a/packages/cel/src/re2/__tests__/UnicodeConformance.test.ts b/packages/re2/src/__tests__/UnicodeConformance.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/UnicodeConformance.test.ts rename to packages/re2/src/__tests__/UnicodeConformance.test.ts diff --git a/packages/cel/src/re2/__tests__/edge-cases.test.ts b/packages/re2/src/__tests__/edge-cases.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/edge-cases.test.ts rename to packages/re2/src/__tests__/edge-cases.test.ts diff --git a/packages/cel/src/re2/__tests__/index.test.ts b/packages/re2/src/__tests__/index.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/index.test.ts rename to packages/re2/src/__tests__/index.test.ts diff --git a/packages/cel/src/re2/__tests__/stability.test.ts b/packages/re2/src/__tests__/stability.test.ts similarity index 100% rename from packages/cel/src/re2/__tests__/stability.test.ts rename to packages/re2/src/__tests__/stability.test.ts diff --git a/packages/cel/src/re2/__utils__/chars.ts b/packages/re2/src/__utils__/chars.ts similarity index 100% rename from packages/cel/src/re2/__utils__/chars.ts rename to packages/re2/src/__utils__/chars.ts diff --git a/packages/cel/src/re2/__utils__/parser.ts b/packages/re2/src/__utils__/parser.ts similarity index 100% rename from packages/cel/src/re2/__utils__/parser.ts rename to packages/re2/src/__utils__/parser.ts diff --git a/packages/cel/src/re2/__utils__/unicode.ts b/packages/re2/src/__utils__/unicode.ts similarity index 100% rename from packages/cel/src/re2/__utils__/unicode.ts rename to packages/re2/src/__utils__/unicode.ts diff --git a/packages/cel/src/re2/exceptions.ts b/packages/re2/src/exceptions.ts similarity index 100% rename from packages/cel/src/re2/exceptions.ts rename to packages/re2/src/exceptions.ts diff --git a/packages/cel/src/re2/index.ts b/packages/re2/src/index.ts similarity index 100% rename from packages/cel/src/re2/index.ts rename to packages/re2/src/index.ts diff --git a/packages/re2/tsconfig.json b/packages/re2/tsconfig.json new file mode 100644 index 0000000..db5192c --- /dev/null +++ b/packages/re2/tsconfig.json @@ -0,0 +1,10 @@ +{ + "files": ["src/index.ts"], + "extends": "../../tsconfig.base.json", + "include": ["src/**/*.test.ts"], + "exclude": [ + "./src/__tests__", + "./src/__fixtures__", + "./src/__utils__" + ] +} diff --git a/scripts/release.js b/scripts/release.js index fde1258..d9a4905 100644 --- a/scripts/release.js +++ b/scripts/release.js @@ -41,6 +41,7 @@ npmPublish(); function npmPublish() { const command = `npm publish --tag ${tag}` + + " --workspace packages/re2" + " --workspace packages/cel" + " --workspace packages/cel-spec"; execSync(command, { From cbcc87b745965673fa050db50a0533dd2692951e Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Fri, 17 Apr 2026 17:30:55 -0400 Subject: [PATCH 04/13] update version in package-lock.json --- package-lock.json | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/package-lock.json b/package-lock.json index 5641b7c..5bf6f68 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2056,7 +2056,7 @@ "license": "Apache-2.0", "dependencies": { "@bufbuild/cel-spec": "0.4.0", - "@bufbuild/re2": "*" + "@bufbuild/re2": "0.4.0" }, "devDependencies": { "@unicode/unicode-16.0.0": "^1.6.16", @@ -2092,11 +2092,10 @@ }, "packages/re2": { "name": "@bufbuild/re2", - "version": "0.1.0", + "version": "0.4.0", "license": "MIT", "devDependencies": { "@unicode/unicode-16.0.0": "^1.6.16", - "expect-type": "^1.3.0", "unicode-property-value-aliases": "^3.9.0" } } From e768b449a492e0ce8557137e4cb66f2d9ffdc532 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Mon, 20 Apr 2026 13:24:21 -0400 Subject: [PATCH 05/13] fix formatting. start fixing lint errors. --- packages/cel/src/std/logic.ts | 2 +- packages/re2/scripts/codepointRange.js | 32 +- packages/re2/scripts/genUnicodeTable.js | 806 +++++----- packages/re2/src/CharClass.ts | 218 +-- packages/re2/src/CharGroup.ts | 128 +- packages/re2/src/Codepoint.ts | 68 +- packages/re2/src/Compiler.ts | 300 ++-- packages/re2/src/DFA.ts | 437 +++--- packages/re2/src/Inst.ts | 76 +- packages/re2/src/MachineInput.ts | 111 +- packages/re2/src/Parser.ts | 1328 +++++++++-------- packages/re2/src/Prefilter.ts | 125 +- packages/re2/src/Prog.ts | 108 +- packages/re2/src/RE2.ts | 275 ++-- packages/re2/src/RE2Flags.ts | 36 +- packages/re2/src/Regexp.ts | 94 +- packages/re2/src/Simplify.ts | 174 ++- packages/re2/src/Unicode.ts | 100 +- packages/re2/src/UnicodeRangeTable.ts | 26 +- packages/re2/src/UnicodeTables.ts | 868 +++++------ packages/re2/src/Utils.ts | 73 +- packages/re2/src/__fixtures__/find.ts | 202 +-- packages/re2/src/__tests__/BugHunt.test.ts | 20 +- packages/re2/src/__tests__/CharClass.test.ts | 99 +- packages/re2/src/__tests__/Codepoint.test.ts | 26 +- packages/re2/src/__tests__/DFA.test.ts | 10 +- packages/re2/src/__tests__/Exec.test.ts | 22 +- packages/re2/src/__tests__/Parser.test.ts | 74 +- packages/re2/src/__tests__/Prefilter.test.ts | 76 +- packages/re2/src/__tests__/RE2Compile.test.ts | 10 +- .../src/__tests__/RE2ExecuteEngine.test.ts | 8 +- packages/re2/src/__tests__/RE2Match.test.ts | 5 +- .../src/__tests__/StressErrorRecovery.test.ts | 5 +- .../src/__tests__/UnicodeConformance.test.ts | 8 +- packages/re2/src/__tests__/edge-cases.test.ts | 68 +- packages/re2/src/__tests__/index.test.ts | 51 +- packages/re2/src/__tests__/stability.test.ts | 9 +- packages/re2/src/__utils__/chars.ts | 2 +- packages/re2/src/__utils__/parser.ts | 148 +- packages/re2/src/__utils__/unicode.ts | 14 +- packages/re2/src/exceptions.ts | 46 +- packages/re2/src/index.ts | 139 +- packages/re2/tsconfig.json | 6 +- 43 files changed, 3433 insertions(+), 3000 deletions(-) diff --git a/packages/cel/src/std/logic.ts b/packages/cel/src/std/logic.ts index f30ebb0..56685ab 100644 --- a/packages/cel/src/std/logic.ts +++ b/packages/cel/src/std/logic.ts @@ -78,7 +78,7 @@ export function matches(this: string, pattern: string): boolean { // // Users can choose to override this function and provide an RE2 engine if they really // need to. - let flagVal: number = 0; + let flagVal = 0; const flagMatches = pattern.match(flagPattern); if (flagMatches) { for (let flag of flagMatches?.groups?.flags ?? "") { diff --git a/packages/re2/scripts/codepointRange.js b/packages/re2/scripts/codepointRange.js index e41cdfb..f9b9807 100644 --- a/packages/re2/scripts/codepointRange.js +++ b/packages/re2/scripts/codepointRange.js @@ -1,29 +1,29 @@ class CodepointRange { constructor() { - this.builder = [] - this.setStart = null - this.setStride = null - this.lastInSet = null + this.builder = []; + this.setStart = null; + this.setStride = null; + this.lastInSet = null; } add(codepoint) { if (this.setStart === null) { - this.setStart = codepoint + this.setStart = codepoint; } else if (this.setStride === null) { - this.setStride = codepoint - this.lastInSet + this.setStride = codepoint - this.lastInSet; } else if (codepoint - this.lastInSet !== this.setStride) { // gotta start a new set - this.builder.push([this.setStart, this.lastInSet, this.setStride]) - this.setStart = codepoint - this.setStride = null + this.builder.push([this.setStart, this.lastInSet, this.setStride]); + this.setStart = codepoint; + this.setStride = null; } - this.lastInSet = codepoint + this.lastInSet = codepoint; } addAll(codepoints) { - const sortedCodepoints = Array.from(codepoints).sort((a, b) => a - b) + const sortedCodepoints = Array.from(codepoints).sort((a, b) => a - b); for (const i of sortedCodepoints) { - this.add(i) + this.add(i); } } @@ -32,11 +32,11 @@ class CodepointRange { this.builder.push([ this.setStart, this.lastInSet, - this.setStride === null ? 1 : this.setStride - ]) + this.setStride === null ? 1 : this.setStride, + ]); } - return this.builder + return this.builder; } } -export { CodepointRange } +export { CodepointRange }; diff --git a/packages/re2/scripts/genUnicodeTable.js b/packages/re2/scripts/genUnicodeTable.js index 519ea7b..98d6f25 100644 --- a/packages/re2/scripts/genUnicodeTable.js +++ b/packages/re2/scripts/genUnicodeTable.js @@ -1,493 +1,509 @@ -import { CodepointRange } from './codepointRange.js' -import unicode16 from '@unicode/unicode-16.0.0' -import unicode15 from '@unicode/unicode-15.0.0' -import CommonCaseFolding from '@unicode/unicode-16.0.0/Case_Folding/C/code-points.js' -import SimpleCaseFolding from '@unicode/unicode-16.0.0/Case_Folding/S/code-points.js' -import unicodePropertyValueAliases from 'unicode-property-value-aliases' +import { CodepointRange } from "./codepointRange.js"; +import unicode16 from "@unicode/unicode-16.0.0"; +import unicode15 from "@unicode/unicode-15.0.0"; +import CommonCaseFolding from "@unicode/unicode-16.0.0/Case_Folding/C/code-points.js"; +import SimpleCaseFolding from "@unicode/unicode-16.0.0/Case_Folding/S/code-points.js"; +import unicodePropertyValueAliases from "unicode-property-value-aliases"; -const MAX_CODE_POINT = 0x10ffff -const SKIP_CATEGORIES = ['cntrl', 'Combining_Mark', 'digit', 'punct'] -const aliasesToNames = unicodePropertyValueAliases.get('General_Category') +const MAX_CODE_POINT = 0x10ffff; +const SKIP_CATEGORIES = ["cntrl", "Combining_Mark", "digit", "punct"]; +const aliasesToNames = unicodePropertyValueAliases.get("General_Category"); // --- CASE_ORBIT (reduced table of non-derivable fold relationships) --- const generateCaseFoldOrbits = () => { - let orbits = new Map() + let orbits = new Map(); for (let i = 0; i < MAX_CODE_POINT; i++) { if (!CommonCaseFolding.has(i) && !SimpleCaseFolding.has(i)) { - continue + continue; } - const f = CommonCaseFolding.get(i) || SimpleCaseFolding.get(i) - let orbit = orbits.get(f) || new Set() - orbit.add(f) - orbit.add(i) - orbits.set(f, orbit) + const f = CommonCaseFolding.get(i) || SimpleCaseFolding.get(i); + let orbit = orbits.get(f) || new Set(); + orbit.add(f); + orbit.add(i); + orbits.set(f, orbit); } for (let i = 0; i < MAX_CODE_POINT; i++) { - if (!orbits.has(i)) continue - if (orbits.get(i).size === 1) orbits.delete(i) + if (!orbits.has(i)) continue; + if (orbits.get(i).size === 1) orbits.delete(i); } - const finalResult = new Map() + const finalResult = new Map(); for (let [key, value] of orbits) { - let orbitWithKey = new Set(value) - orbitWithKey.add(key) - orbitWithKey = Array.from(orbitWithKey).sort((a, b) => a - b) - let a = orbitWithKey[0] + let orbitWithKey = new Set(value); + orbitWithKey.add(key); + orbitWithKey = Array.from(orbitWithKey).sort((a, b) => a - b); + let a = orbitWithKey[0]; for (let i of orbitWithKey.slice(1)) { - finalResult.set(a, i) - a = i + finalResult.set(a, i); + a = i; } - finalResult.set(orbitWithKey[orbitWithKey.length - 1], orbitWithKey[0]) + finalResult.set(orbitWithKey[orbitWithKey.length - 1], orbitWithKey[0]); } - return finalResult -} + return finalResult; +}; -const sortedOrbits = generateCaseFoldOrbits() +const sortedOrbits = generateCaseFoldOrbits(); // rawSimpleFold mirrors the runtime Unicode.simpleFold fallback: raw // String.prototype.toLowerCase/toUpperCase with a length check to reject // multi-char expansions (e.g. ß→SS). Used to reduce CASE_ORBIT to only // entries where raw native disagrees with the correct fold. const rawSimpleFold = (r) => { - const s = String.fromCodePoint(r) - const lower = s.toLowerCase() + const s = String.fromCodePoint(r); + const lower = s.toLowerCase(); if (lower.length === s.length) { - const lowerCp = lower.codePointAt(0) - if (lowerCp !== r) return lowerCp + const lowerCp = lower.codePointAt(0); + if (lowerCp !== r) return lowerCp; } - const upper = s.toUpperCase() + const upper = s.toUpperCase(); if (upper.length === s.length) { - const upperCp = upper.codePointAt(0) - if (upperCp !== r) return upperCp + const upperCp = upper.codePointAt(0); + if (upperCp !== r) return upperCp; } - return r -} + return r; +}; const buildReducedOrbit = () => { - const reduced = new Map() + const reduced = new Map(); for (const [r, v] of sortedOrbits) { - if (rawSimpleFold(r) !== v) reduced.set(r, v) + if (rawSimpleFold(r) !== v) reduced.set(r, v); } for (let r = 0; r < MAX_CODE_POINT; r++) { - if (r >= 0xd800 && r <= 0xdfff) continue - if (sortedOrbits.has(r)) continue - if (rawSimpleFold(r) !== r) reduced.set(r, r) + if (r >= 0xd800 && r <= 0xdfff) continue; + if (sortedOrbits.has(r)) continue; + if (rawSimpleFold(r) !== r) reduced.set(r, r); } - return reduced -} + return reduced; +}; -const reducedOrbit = buildReducedOrbit() +const reducedOrbit = buildReducedOrbit(); // --- Loaders --- const loadCodePoints = async (pkg, type, name) => { try { - const { default: codePoints } = await import(`${pkg}/${type}/${name}/code-points.js`) - return new Set(codePoints) + const { default: codePoints } = await import( + `${pkg}/${type}/${name}/code-points.js` + ); + return new Set(codePoints); } catch (_e) { - return null + return null; } -} +}; const computeRanges = (codepoints) => { - if (codepoints.size === 0) return [] - const gen = new CodepointRange() - gen.addAll(Array.from(codepoints).sort((a, b) => a - b)) - return gen.finish() -} + if (codepoints.size === 0) return []; + const gen = new CodepointRange(); + gen.addAll(Array.from(codepoints).sort((a, b) => a - b)); + return gen.finish(); +}; const setDiff = (a, b) => { - if (!b) return new Set(a) - const out = new Set() - for (const x of a) if (!b.has(x)) out.add(x) - return out -} + if (!b) return new Set(a); + const out = new Set(); + for (const x of a) if (!b.has(x)) out.add(x); + return out; +}; // --- VLQ --- -const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-' +const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-"; const encodeVLQ = (value) => { - let res = '' + let res = ""; do { - let digit = value & 0x1f - value >>>= 5 - if (value > 0) digit |= 0x20 - res += B64[digit] - } while (value > 0) - return res -} + let digit = value & 0x1f; + value >>>= 5; + if (value > 0) digit |= 0x20; + res += B64[digit]; + } while (value > 0); + return res; +}; const encodeRanges = (ranges) => { - if (ranges.length === 0) return { encoded: '', stride1: true, empty: true } - let encoded = '' - let current = 0 - const stride1 = ranges.every((r) => r[2] === 1) + if (ranges.length === 0) return { encoded: "", stride1: true, empty: true }; + let encoded = ""; + let current = 0; + const stride1 = ranges.every((r) => r[2] === 1); for (const r of ranges) { - encoded += encodeVLQ(r[0] - current) - encoded += encodeVLQ(r[1] - r[0]) - if (!stride1) encoded += encodeVLQ(r[2]) - current = r[1] + encoded += encodeVLQ(r[0] - current); + encoded += encodeVLQ(r[1] - r[0]); + if (!stride1) encoded += encodeVLQ(r[2]); + current = r[1]; } - return { encoded, stride1, empty: false } -} + return { encoded, stride1, empty: false }; +}; // --- Delta computation --- -const deltaCatLines = [] -const deltaScrLines = [] -const newScriptLines = [] -const stableCategoryNames = [] -const stableScriptNames = [] -const newScriptNames = [] +const deltaCatLines = []; +const deltaScrLines = []; +const newScriptLines = []; +const stableCategoryNames = []; +const stableScriptNames = []; +const newScriptNames = []; for (const [alias, name] of aliasesToNames.entries()) { - if (SKIP_CATEGORIES.includes(alias)) continue - const cp16 = await loadCodePoints('@unicode/unicode-16.0.0', 'General_Category', name) - if (!cp16) continue - const cp15 = await loadCodePoints('@unicode/unicode-15.0.0', 'General_Category', name) - stableCategoryNames.push(alias) - const delta = setDiff(cp16, cp15) + if (SKIP_CATEGORIES.includes(alias)) continue; + const cp16 = await loadCodePoints( + "@unicode/unicode-16.0.0", + "General_Category", + name, + ); + if (!cp16) continue; + const cp15 = await loadCodePoints( + "@unicode/unicode-15.0.0", + "General_Category", + name, + ); + stableCategoryNames.push(alias); + const delta = setDiff(cp16, cp15); if (delta.size > 0) { - const ranges = computeRanges(delta) - const enc = encodeRanges(ranges) - deltaCatLines.push(` '${alias}': () => decodeRanges('${enc.encoded}', ${enc.stride1}),`) + const ranges = computeRanges(delta); + const enc = encodeRanges(ranges); + deltaCatLines.push( + ` '${alias}': () => decodeRanges('${enc.encoded}', ${enc.stride1}),`, + ); } } -for (const name of unicode16['Script']) { - const cp16 = await loadCodePoints('@unicode/unicode-16.0.0', 'Script', name) - if (!cp16) continue - const cp15 = await loadCodePoints('@unicode/unicode-15.0.0', 'Script', name) +for (const name of unicode16["Script"]) { + const cp16 = await loadCodePoints("@unicode/unicode-16.0.0", "Script", name); + if (!cp16) continue; + const cp15 = await loadCodePoints("@unicode/unicode-15.0.0", "Script", name); if (cp15) { - stableScriptNames.push(name) - const delta = setDiff(cp16, cp15) + stableScriptNames.push(name); + const delta = setDiff(cp16, cp15); if (delta.size > 0) { - const ranges = computeRanges(delta) - const enc = encodeRanges(ranges) - deltaScrLines.push(` '${name}': () => decodeRanges('${enc.encoded}', ${enc.stride1}),`) + const ranges = computeRanges(delta); + const enc = encodeRanges(ranges); + deltaScrLines.push( + ` '${name}': () => decodeRanges('${enc.encoded}', ${enc.stride1}),`, + ); } } else { - newScriptNames.push(name) - const ranges = computeRanges(cp16) - const enc = encodeRanges(ranges) + newScriptNames.push(name); + const ranges = computeRanges(cp16); + const enc = encodeRanges(ranges); newScriptLines.push( - ` '${name}': () => new UnicodeRangeTable(decodeRanges('${enc.encoded}', ${enc.stride1})),` - ) + ` '${name}': () => new UnicodeRangeTable(decodeRanges('${enc.encoded}', ${enc.stride1})),`, + ); } } // --- CASE_ORBIT encoding --- -const caseOrbitEntries = Array.from(reducedOrbit.entries()).sort((a, b) => a[0] - b[0]) -let orbitEnc = '' -let curr = 0 +const caseOrbitEntries = Array.from(reducedOrbit.entries()).sort( + (a, b) => a[0] - b[0], +); +let orbitEnc = ""; +let curr = 0; for (const [k, v] of caseOrbitEntries) { - orbitEnc += encodeVLQ(k - curr) - orbitEnc += encodeVLQ(v) - curr = k + orbitEnc += encodeVLQ(k - curr); + orbitEnc += encodeVLQ(v); + curr = k; } // --- Emit UnicodeTables.ts --- const code = [ - '// GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT.', - '// yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts', - '', + "// GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT.", + "// yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts", + "", "import { UnicodeRangeTable } from './UnicodeRangeTable'", - '', - 'let _B64_MAP: Uint8Array | null = null', - 'const getB64Map = (): Uint8Array => {', - ' if (!_B64_MAP) {', - ' _B64_MAP = new Uint8Array(256)', + "", + "let _B64_MAP: Uint8Array | null = null", + "const getB64Map = (): Uint8Array => {", + " if (!_B64_MAP) {", + " _B64_MAP = new Uint8Array(256)", ` const b = '${B64}'`, - ' for (let i = 0; i < 64; i++) {', - ' _B64_MAP[b.charCodeAt(i)] = i', - ' }', - ' }', - ' return _B64_MAP', - '}', - '', - 'const decodeVLQ = (str: string): number[] => {', - ' const b64 = getB64Map()', - ' const res: number[] = []', - ' let value = 0, shift = 0', - ' for (let i = 0; i < str.length; i++) {', - ' const digit = b64[str.charCodeAt(i)]', - ' value |= (digit & 0x1f) << shift', - ' if ((digit & 0x20) === 0) {', - ' res.push(value)', - ' value = 0', - ' shift = 0', - ' } else {', - ' shift += 5', - ' }', - ' }', - ' return res', - '}', - '', - 'const decodeRanges = (str: string, isStride1: boolean): Uint32Array => {', - ' if (str.length === 0) return new Uint32Array(0)', - ' const res = decodeVLQ(str)', - ' const numRanges = isStride1 ? res.length / 2 : res.length / 3', - ' const out = new Uint32Array(numRanges * 3)', - ' let current = 0, resIdx = 0', - ' for (let i = 0; i < numRanges; i++) {', - ' current += res[resIdx++]', - ' out[i * 3] = current', - ' current += res[resIdx++]', - ' out[i * 3 + 1] = current', - ' out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++]', - ' }', - ' return out', - '}', - '', - 'const decodeOrbit = (str: string): Map => {', - ' const res = decodeVLQ(str)', - ' const map = new Map()', - ' let currentKey = 0', - ' for (let i = 0; i < res.length; i += 2) {', - ' currentKey += res[i]', - ' map.set(currentKey, res[i + 1])', - ' }', - ' return map', - '}', - '', - '// Merges two stride-encoded UnicodeRangeTables. Expands any stride>1', - '// ranges to individual codepoints, then coalesces contiguous runs.', - 'const mergeRanges = (a: Uint32Array, b: Uint32Array): Uint32Array => {', - ' if (b.length === 0) return a', - ' if (a.length === 0) return b', - ' const points: [number, number][] = []', - ' const push = (arr: Uint32Array): void => {', - ' for (let i = 0; i < arr.length; i += 3) {', - ' const lo = arr[i], hi = arr[i + 1], stride = arr[i + 2]', - ' if (stride === 1) {', - ' points.push([lo, hi])', - ' } else {', - ' for (let cp = lo; cp <= hi; cp += stride) points.push([cp, cp])', - ' }', - ' }', - ' }', - ' push(a)', - ' push(b)', - ' points.sort((x, y) => x[0] - y[0])', - ' const merged: [number, number][] = []', - ' for (const [lo, hi] of points) {', - ' const last = merged[merged.length - 1]', - ' if (last && last[1] + 1 >= lo) {', - ' if (hi > last[1]) last[1] = hi', - ' } else {', - ' merged.push([lo, hi])', - ' }', - ' }', - ' const out = new Uint32Array(merged.length * 3)', - ' for (let i = 0; i < merged.length; i++) {', - ' out[i * 3] = merged[i][0]', - ' out[i * 3 + 1] = merged[i][1]', - ' out[i * 3 + 2] = 1', - ' }', - ' return out', - '}', - '', - '// Sweeps the codepoint space using a platform property-escape regex and', - '// returns stride-1 ranges. Surrogates are included — String.fromCodePoint', - '// returns the lone surrogate char and platform regex matches \\p{Cs} on it.', - 'const sweepPlatform = (pattern: string): Uint32Array => {', + " for (let i = 0; i < 64; i++) {", + " _B64_MAP[b.charCodeAt(i)] = i", + " }", + " }", + " return _B64_MAP", + "}", + "", + "const decodeVLQ = (str: string): number[] => {", + " const b64 = getB64Map()", + " const res: number[] = []", + " let value = 0, shift = 0", + " for (let i = 0; i < str.length; i++) {", + " const digit = b64[str.charCodeAt(i)]", + " value |= (digit & 0x1f) << shift", + " if ((digit & 0x20) === 0) {", + " res.push(value)", + " value = 0", + " shift = 0", + " } else {", + " shift += 5", + " }", + " }", + " return res", + "}", + "", + "const decodeRanges = (str: string, isStride1: boolean): Uint32Array => {", + " if (str.length === 0) return new Uint32Array(0)", + " const res = decodeVLQ(str)", + " const numRanges = isStride1 ? res.length / 2 : res.length / 3", + " const out = new Uint32Array(numRanges * 3)", + " let current = 0, resIdx = 0", + " for (let i = 0; i < numRanges; i++) {", + " current += res[resIdx++]", + " out[i * 3] = current", + " current += res[resIdx++]", + " out[i * 3 + 1] = current", + " out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++]", + " }", + " return out", + "}", + "", + "const decodeOrbit = (str: string): Map => {", + " const res = decodeVLQ(str)", + " const map = new Map()", + " let currentKey = 0", + " for (let i = 0; i < res.length; i += 2) {", + " currentKey += res[i]", + " map.set(currentKey, res[i + 1])", + " }", + " return map", + "}", + "", + "// Merges two stride-encoded UnicodeRangeTables. Expands any stride>1", + "// ranges to individual codepoints, then coalesces contiguous runs.", + "const mergeRanges = (a: Uint32Array, b: Uint32Array): Uint32Array => {", + " if (b.length === 0) return a", + " if (a.length === 0) return b", + " const points: [number, number][] = []", + " const push = (arr: Uint32Array): void => {", + " for (let i = 0; i < arr.length; i += 3) {", + " const lo = arr[i], hi = arr[i + 1], stride = arr[i + 2]", + " if (stride === 1) {", + " points.push([lo, hi])", + " } else {", + " for (let cp = lo; cp <= hi; cp += stride) points.push([cp, cp])", + " }", + " }", + " }", + " push(a)", + " push(b)", + " points.sort((x, y) => x[0] - y[0])", + " const merged: [number, number][] = []", + " for (const [lo, hi] of points) {", + " const last = merged[merged.length - 1]", + " if (last && last[1] + 1 >= lo) {", + " if (hi > last[1]) last[1] = hi", + " } else {", + " merged.push([lo, hi])", + " }", + " }", + " const out = new Uint32Array(merged.length * 3)", + " for (let i = 0; i < merged.length; i++) {", + " out[i * 3] = merged[i][0]", + " out[i * 3 + 1] = merged[i][1]", + " out[i * 3 + 2] = 1", + " }", + " return out", + "}", + "", + "// Sweeps the codepoint space using a platform property-escape regex and", + "// returns stride-1 ranges. Surrogates are included — String.fromCodePoint", + "// returns the lone surrogate char and platform regex matches \\p{Cs} on it.", + "const sweepPlatform = (pattern: string): Uint32Array => {", ' const re = new RegExp(pattern, "u")', - ' const ranges: number[] = []', - ' let start = -1', - ' for (let cp = 0; cp <= 0x10ffff; cp++) {', - ' if (re.test(String.fromCodePoint(cp))) {', - ' if (start < 0) start = cp', - ' } else if (start >= 0) {', - ' ranges.push(start, cp - 1, 1)', - ' start = -1', - ' }', - ' }', - ' if (start >= 0) ranges.push(start, 0x10ffff, 1)', - ' return Uint32Array.from(ranges)', - '}', - '', - 'class LazyDecoder {', - ' private readonly initializer: Record V>', - ' private readonly cache: Map', - ' constructor(initializer: Record V>) {', - ' this.initializer = initializer', - ' this.cache = new Map()', - ' }', - ' has(key: string): boolean { return key in this.initializer }', - ' get(key: string): V | null {', - ' if (this.cache.has(key)) return this.cache.get(key)!', - ' const fn = this.initializer[key]', - ' const val = fn ? fn() : null', - ' this.cache.set(key, val)', - ' return val', - ' }', - '}', - '', - 'class UnicodeTables {', - ' private static _CASE_ORBIT: Map | null = null', - ' static get CASE_ORBIT(): Map {', - ' if (!this._CASE_ORBIT) {', + " const ranges: number[] = []", + " let start = -1", + " for (let cp = 0; cp <= 0x10ffff; cp++) {", + " if (re.test(String.fromCodePoint(cp))) {", + " if (start < 0) start = cp", + " } else if (start >= 0) {", + " ranges.push(start, cp - 1, 1)", + " start = -1", + " }", + " }", + " if (start >= 0) ranges.push(start, 0x10ffff, 1)", + " return Uint32Array.from(ranges)", + "}", + "", + "class LazyDecoder {", + " private readonly initializer: Record V>", + " private readonly cache: Map", + " constructor(initializer: Record V>) {", + " this.initializer = initializer", + " this.cache = new Map()", + " }", + " has(key: string): boolean { return key in this.initializer }", + " get(key: string): V | null {", + " if (this.cache.has(key)) return this.cache.get(key)!", + " const fn = this.initializer[key]", + " const val = fn ? fn() : null", + " this.cache.set(key, val)", + " return val", + " }", + "}", + "", + "class UnicodeTables {", + " private static _CASE_ORBIT: Map | null = null", + " static get CASE_ORBIT(): Map {", + " if (!this._CASE_ORBIT) {", ` this._CASE_ORBIT = decodeOrbit('${orbitEnc}')`, - ' }', - ' return this._CASE_ORBIT', - ' }', - '', - ' // Additions from Unicode 15.0 → 16.0 per stable general-category name.', - ' // Merged unconditionally with platform sweep output; no-op on 16.0+ engines.', - ' private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({', + " }", + " return this._CASE_ORBIT", + " }", + "", + " // Additions from Unicode 15.0 → 16.0 per stable general-category name.", + " // Merged unconditionally with platform sweep output; no-op on 16.0+ engines.", + " private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({", ...deltaCatLines, - ' })', - '', - ' // Additions from Unicode 15.0 → 16.0 per stable script name.', - ' private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({', + " })", + "", + " // Additions from Unicode 15.0 → 16.0 per stable script name.", + " private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({", ...deltaScrLines, - ' })', - '', - ' // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw', - ' // SyntaxError on these names, so platform sweep is impossible.', - ' private static _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({', + " })", + "", + " // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw", + " // SyntaxError on these names, so platform sweep is impossible.", + " private static _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({", ...newScriptLines, - ' })', - '', + " })", + "", ` static readonly STABLE_CATEGORY_NAMES: ReadonlySet = new Set(${JSON.stringify(stableCategoryNames)})`, ` static readonly STABLE_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(stableScriptNames)})`, ` static readonly NEW_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(newScriptNames)})`, - '', - ' private static _sweepCache = new Map()', - ' private static _foldCache = new Map()', - '', - ' // Returns the base range table for a property name, or null if unknown.', - ' // Stable names: platform sweep + bundled delta (15.0 → 16.0).', - ' // New-in-16.0 script names: bundled full table.', - ' static buildForProperty(name: string): UnicodeRangeTable | null {', - ' if (this.NEW_SCRIPT_NAMES.has(name)) {', - ' return this._NEW_SCRIPTS.get(name)', - ' }', + "", + " private static _sweepCache = new Map()", + " private static _foldCache = new Map()", + "", + " // Returns the base range table for a property name, or null if unknown.", + " // Stable names: platform sweep + bundled delta (15.0 → 16.0).", + " // New-in-16.0 script names: bundled full table.", + " static buildForProperty(name: string): UnicodeRangeTable | null {", + " if (this.NEW_SCRIPT_NAMES.has(name)) {", + " return this._NEW_SCRIPTS.get(name)", + " }", ' let kind: "category" | "script" | null = null', - ' let pattern: string | null = null', + " let pattern: string | null = null", ' if (this.STABLE_CATEGORY_NAMES.has(name)) { kind = "category"; pattern = `\\\\p{General_Category=${name}}` }', ' else if (this.STABLE_SCRIPT_NAMES.has(name)) { kind = "script"; pattern = `\\\\p{Script=${name}}` }', - ' else return null', - '', - ' const cacheKey = `${kind}:${name}`', - ' const cached = this._sweepCache.get(cacheKey)', - ' if (cached) return cached', - '', - ' const base = sweepPlatform(pattern)', + " else return null", + "", + " const cacheKey = `${kind}:${name}`", + " const cached = this._sweepCache.get(cacheKey)", + " if (cached) return cached", + "", + " const base = sweepPlatform(pattern)", ' const delta = kind === "category" ? this._DELTA_CATEGORIES.get(name) : this._DELTA_SCRIPTS.get(name)', - ' const merged = delta ? mergeRanges(base, delta) : base', - ' const table = new UnicodeRangeTable(merged)', - ' this._sweepCache.set(cacheKey, table)', - ' return table', - ' }', - '', - ' // Computes the fold-overlay for a property name: additional runes that', - ' // fold to some rune already in the base class. Returns null if no overlay', - ' // is needed (base class is fold-stable).', - ' static buildFoldOverlay(name: string): UnicodeRangeTable | null {', - ' const cached = this._foldCache.get(name)', - ' if (cached !== undefined) return cached', - ' const base = this.buildForProperty(name)', - ' if (!base) {', - ' this._foldCache.set(name, null)', - ' return null', - ' }', - ' const inBase = (r: number): boolean => {', - ' let lo = 0, hi = base.length', - ' while (lo < hi) {', - ' const m = (lo + hi) >> 1', - ' const rlo = base.getLo(m), rhi = base.getHi(m)', - ' if (r < rlo) hi = m', - ' else if (r > rhi) lo = m + 1', - ' else return ((r - rlo) % base.getStride(m)) === 0', - ' }', - ' return false', - ' }', - ' // Inline simpleFold to avoid circular import with Unicode.ts.', - ' const orbit = UnicodeTables.CASE_ORBIT', - ' const simpleFold = (r: number): number => {', - ' if (orbit.has(r)) return orbit.get(r)!', - ' const s = String.fromCodePoint(r)', - ' const lower = s.toLowerCase()', - ' if (lower.length === s.length) {', - ' const lowerCp = lower.codePointAt(0)!', - ' if (lowerCp !== r) return lowerCp', - ' }', - ' const upper = s.toUpperCase()', - ' if (upper.length === s.length) {', - ' const upperCp = upper.codePointAt(0)!', - ' if (upperCp !== r) return upperCp', - ' }', - ' return r', - ' }', - ' const extras = new Set()', - ' for (let i = 0; i < base.length; i++) {', - ' const lo = base.getLo(i), hi = base.getHi(i), stride = base.getStride(i)', - ' for (let cp = lo; cp <= hi; cp += stride) {', - ' let r = simpleFold(cp)', - ' while (r !== cp) {', - ' if (!inBase(r)) extras.add(r)', - ' r = simpleFold(r)', - ' }', - ' }', - ' }', - ' if (extras.size === 0) {', - ' this._foldCache.set(name, null)', - ' return null', - ' }', - ' const sorted = Array.from(extras).sort((a, b) => a - b)', - ' const merged: [number, number][] = []', - ' for (const cp of sorted) {', - ' const last = merged[merged.length - 1]', - ' if (last && last[1] + 1 === cp) last[1] = cp', - ' else merged.push([cp, cp])', - ' }', - ' const out = new Uint32Array(merged.length * 3)', - ' for (let i = 0; i < merged.length; i++) {', - ' out[i * 3] = merged[i][0]', - ' out[i * 3 + 1] = merged[i][1]', - ' out[i * 3 + 2] = 1', - ' }', - ' const table = new UnicodeRangeTable(out)', - ' this._foldCache.set(name, table)', - ' return table', - ' }', - '', - ' // --- Legacy API surface used by Parser ---', - '', - ' static CATEGORIES = {', - ' has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),', - ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)', - ' }', - '', - ' static SCRIPTS = {', - ' has: (name: string): boolean =>', - ' UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),', - ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)', - ' }', - '', - ' static FOLD_CATEGORIES = {', - ' has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),', - ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)', - ' }', - '', - ' static FOLD_SCRIPT = {', - ' has: (name: string): boolean =>', - ' UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),', - ' get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)', - ' }', - '', + " const merged = delta ? mergeRanges(base, delta) : base", + " const table = new UnicodeRangeTable(merged)", + " this._sweepCache.set(cacheKey, table)", + " return table", + " }", + "", + " // Computes the fold-overlay for a property name: additional runes that", + " // fold to some rune already in the base class. Returns null if no overlay", + " // is needed (base class is fold-stable).", + " static buildFoldOverlay(name: string): UnicodeRangeTable | null {", + " const cached = this._foldCache.get(name)", + " if (cached !== undefined) return cached", + " const base = this.buildForProperty(name)", + " if (!base) {", + " this._foldCache.set(name, null)", + " return null", + " }", + " const inBase = (r: number): boolean => {", + " let lo = 0, hi = base.length", + " while (lo < hi) {", + " const m = (lo + hi) >> 1", + " const rlo = base.getLo(m), rhi = base.getHi(m)", + " if (r < rlo) hi = m", + " else if (r > rhi) lo = m + 1", + " else return ((r - rlo) % base.getStride(m)) === 0", + " }", + " return false", + " }", + " // Inline simpleFold to avoid circular import with Unicode.ts.", + " const orbit = UnicodeTables.CASE_ORBIT", + " const simpleFold = (r: number): number => {", + " if (orbit.has(r)) return orbit.get(r)!", + " const s = String.fromCodePoint(r)", + " const lower = s.toLowerCase()", + " if (lower.length === s.length) {", + " const lowerCp = lower.codePointAt(0)!", + " if (lowerCp !== r) return lowerCp", + " }", + " const upper = s.toUpperCase()", + " if (upper.length === s.length) {", + " const upperCp = upper.codePointAt(0)!", + " if (upperCp !== r) return upperCp", + " }", + " return r", + " }", + " const extras = new Set()", + " for (let i = 0; i < base.length; i++) {", + " const lo = base.getLo(i), hi = base.getHi(i), stride = base.getStride(i)", + " for (let cp = lo; cp <= hi; cp += stride) {", + " let r = simpleFold(cp)", + " while (r !== cp) {", + " if (!inBase(r)) extras.add(r)", + " r = simpleFold(r)", + " }", + " }", + " }", + " if (extras.size === 0) {", + " this._foldCache.set(name, null)", + " return null", + " }", + " const sorted = Array.from(extras).sort((a, b) => a - b)", + " const merged: [number, number][] = []", + " for (const cp of sorted) {", + " const last = merged[merged.length - 1]", + " if (last && last[1] + 1 === cp) last[1] = cp", + " else merged.push([cp, cp])", + " }", + " const out = new Uint32Array(merged.length * 3)", + " for (let i = 0; i < merged.length; i++) {", + " out[i * 3] = merged[i][0]", + " out[i * 3 + 1] = merged[i][1]", + " out[i * 3 + 2] = 1", + " }", + " const table = new UnicodeRangeTable(out)", + " this._foldCache.set(name, table)", + " return table", + " }", + "", + " // --- Legacy API surface used by Parser ---", + "", + " static CATEGORIES = {", + " has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)", + " }", + "", + " static SCRIPTS = {", + " has: (name: string): boolean =>", + " UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)", + " }", + "", + " static FOLD_CATEGORIES = {", + " has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)", + " }", + "", + " static FOLD_SCRIPT = {", + " has: (name: string): boolean =>", + " UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)", + " }", + "", ' static get Upper(): UnicodeRangeTable { return UnicodeTables.buildForProperty("Lu")! }', - '}', - '', - 'export { UnicodeTables }', - '' -] + "}", + "", + "export { UnicodeTables }", + "", +]; -console.log(code.join('\n')) // eslint-disable-line no-console +console.log(code.join("\n")); // eslint-disable-line no-console diff --git a/packages/re2/src/CharClass.ts b/packages/re2/src/CharClass.ts index 7fb19d1..8a10058 100644 --- a/packages/re2/src/CharClass.ts +++ b/packages/re2/src/CharClass.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from './RE2Flags.js' -import { Unicode } from './Unicode.js' -import { Utils } from './Utils.js' +import { RE2Flags } from "./RE2Flags.js"; +import { Unicode } from "./Unicode.js"; +import { Utils } from "./Utils.js"; /** * A "builder"-style helper class for manipulating character classes represented as an array of * pairs of runes [lo, hi], each denoting an inclusive interval. @@ -11,56 +11,61 @@ class CharClass { // cmp() returns the ordering of the pair (a[i], a[i+1]) relative to // (pivotFrom, pivotTo), where the first component of the pair (lo) is // ordered naturally and the second component (hi) is in reverse order. - static cmp(array: number[], i: number, pivotFrom: number, pivotTo: number): number { - const cmp = array[i] - pivotFrom - return cmp !== 0 ? cmp : pivotTo - array[i + 1] + static cmp( + array: number[], + i: number, + pivotFrom: number, + pivotTo: number, + ): number { + const cmp = array[i] - pivotFrom; + return cmp !== 0 ? cmp : pivotTo - array[i + 1]; } // qsortIntPair() quicksorts pairs of ints in |array| according to lt(). // Precondition: |left|, |right|, |this.len| must all be even; |this.len > 1|. static qsortIntPair(array: number[], left: number, right: number): void { - const pivotIndex = (((left + right) / 2) | 0) & ~1 - const pivotFrom = array[pivotIndex] - const pivotTo = array[pivotIndex + 1] - let i = left - let j = right + const pivotIndex = (((left + right) / 2) | 0) & ~1; + const pivotFrom = array[pivotIndex]; + const pivotTo = array[pivotIndex + 1]; + let i = left; + let j = right; while (i <= j) { while (i < right && CharClass.cmp(array, i, pivotFrom, pivotTo) < 0) { - i += 2 + i += 2; } while (j > left && CharClass.cmp(array, j, pivotFrom, pivotTo) > 0) { - j -= 2 + j -= 2; } if (i <= j) { if (i !== j) { - let temp = array[i] - array[i] = array[j] - array[j] = temp - temp = array[i + 1] - array[i + 1] = array[j + 1] - array[j + 1] = temp + let temp = array[i]; + array[i] = array[j]; + array[j] = temp; + temp = array[i + 1]; + array[i + 1] = array[j + 1]; + array[j + 1] = temp; } - i += 2 - j -= 2 + i += 2; + j -= 2; } } if (left < j) { - CharClass.qsortIntPair(array, left, j) + CharClass.qsortIntPair(array, left, j); } if (i < right) { - CharClass.qsortIntPair(array, i, right) + CharClass.qsortIntPair(array, i, right); } } - r: any - len: number + r: number[]; + len: number; constructor(r = Utils.emptyInts()) { - this.r = r // inclusive ranges, pairs of [lo,hi]. r.length is even. - this.len = r.length // prefix of |r| that is defined. Even. + this.r = r; // inclusive ranges, pairs of [lo,hi]. r.length is even. + this.len = r.length; // prefix of |r| that is defined. Even. } // Returns the character class as an int array. Subsequent CharClass @@ -68,48 +73,47 @@ class CharClass { // performed on a given CharClass instance. toArray(): number[] { if (this.len === this.r.length) { - return this.r - } else { - return this.r.slice(0, this.len) + return this.r; } + return this.r.slice(0, this.len); } // cleanClass() sorts the ranges (pairs of elements) of this CharClass, // merges them, and eliminates duplicates. cleanClass(): this { if (this.len < 4) { - return this + return this; } // Sort by lo increasing, hi decreasing to break ties. - CharClass.qsortIntPair(this.r, 0, this.len - 2) + CharClass.qsortIntPair(this.r, 0, this.len - 2); // Merge abutting, overlapping. - let w = 2 // write index + let w = 2; // write index for (let i = 2; i < this.len; i += 2) { { - const lo = this.r[i] - const hi = this.r[i + 1] + const lo = this.r[i]; + const hi = this.r[i + 1]; if (lo <= this.r[w - 1] + 1) { // merge with previous range if (hi > this.r[w - 1]) { - this.r[w - 1] = hi + this.r[w - 1] = hi; } - continue + continue; } // new disjoint range - this.r[w] = lo - this.r[w + 1] = hi - w += 2 + this.r[w] = lo; + this.r[w + 1] = hi; + w += 2; } } - this.len = w - return this + this.len = w; + return this; } // appendLiteral() appends the literal |x| to this CharClass. appendLiteral(x: number, flags: number): this { return (flags & RE2Flags.FOLD_CASE) !== 0 ? this.appendFoldedRange(x, x) - : this.appendRange(x, x) + : this.appendRange(x, x); } // appendRange() appends the range [lo-hi] (inclusive) to this CharClass. @@ -122,24 +126,24 @@ class CharClass { for (let i = 2; i <= 4; i += 2) { // twice, using i=2, i=4 if (this.len >= i) { - const rlo = this.r[this.len - i] - const rhi = this.r[this.len - i + 1] + const rlo = this.r[this.len - i]; + const rhi = this.r[this.len - i + 1]; if (lo <= rhi + 1 && rlo <= hi + 1) { if (lo < rlo) { - this.r[this.len - i] = lo + this.r[this.len - i] = lo; } if (hi > rhi) { - this.r[this.len - i + 1] = hi + this.r[this.len - i + 1] = hi; } - return this + return this; } } } } - this.r[this.len++] = lo - this.r[this.len++] = hi - return this + this.r[this.len++] = lo; + this.r[this.len++] = hi; + return this; } // appendFoldedRange() appends the range [lo-hi] and its case @@ -148,159 +152,159 @@ class CharClass { // Optimizations. if (lo <= Unicode.MIN_FOLD && hi >= Unicode.MAX_FOLD) { // Range is full: folding can't add more. - return this.appendRange(lo, hi) + return this.appendRange(lo, hi); } if (hi < Unicode.MIN_FOLD || lo > Unicode.MAX_FOLD) { // Range is outside folding possibilities. - return this.appendRange(lo, hi) + return this.appendRange(lo, hi); } if (lo < Unicode.MIN_FOLD) { // [lo, minFold-1] needs no folding. - this.appendRange(lo, Unicode.MIN_FOLD - 1) - lo = Unicode.MIN_FOLD + this.appendRange(lo, Unicode.MIN_FOLD - 1); + lo = Unicode.MIN_FOLD; } if (hi > Unicode.MAX_FOLD) { // [maxFold+1, hi] needs no folding. - this.appendRange(Unicode.MAX_FOLD + 1, hi) - hi = Unicode.MAX_FOLD + this.appendRange(Unicode.MAX_FOLD + 1, hi); + hi = Unicode.MAX_FOLD; } // Brute force. Depend on appendRange to coalesce ranges on the fly. for (let c = lo; c <= hi; c++) { - this.appendRange(c, c) + this.appendRange(c, c); for (let f = Unicode.simpleFold(c); f !== c; f = Unicode.simpleFold(f)) { - this.appendRange(f, f) + this.appendRange(f, f); } } - return this + return this; } // appendClass() appends the class |x| to this CharClass. // It assumes |x| is clean. Does not mutate |x|. appendClass(x: number[]): this { for (let i = 0; i < x.length; i += 2) { - this.appendRange(x[i], x[i + 1]) + this.appendRange(x[i], x[i + 1]); } - return this + return this; } // appendFoldedClass() appends the case folding of the class |x| to this // CharClass. Does not mutate |x|. appendFoldedClass(x: number[]): this { for (let i = 0; i < x.length; i += 2) { - this.appendFoldedRange(x[i], x[i + 1]) + this.appendFoldedRange(x[i], x[i + 1]); } - return this + return this; } // appendNegatedClass() append the negation of the class |x| to this // CharClass. It assumes |x| is clean. Does not mutate |x|. appendNegatedClass(x: number[]): this { - let nextLo = 0 + let nextLo = 0; for (let i = 0; i < x.length; i += 2) { - const lo = x[i] - const hi = x[i + 1] + const lo = x[i]; + const hi = x[i + 1]; if (nextLo <= lo - 1) { - this.appendRange(nextLo, lo - 1) + this.appendRange(nextLo, lo - 1); } - nextLo = hi + 1 + nextLo = hi + 1; } if (nextLo <= Unicode.MAX_RUNE) { - this.appendRange(nextLo, Unicode.MAX_RUNE) + this.appendRange(nextLo, Unicode.MAX_RUNE); } - return this + return this; } // appendTable() appends the Unicode range table |table| to this CharClass. // Does not mutate |table|. appendTable(table: any): this { for (let i = 0; i < table.length; ++i) { - const lo = table.getLo(i) - const hi = table.getHi(i) - const stride = table.getStride(i) + const lo = table.getLo(i); + const hi = table.getHi(i); + const stride = table.getStride(i); if (stride === 1) { - this.appendRange(lo, hi) - continue + this.appendRange(lo, hi); + continue; } for (let c = lo; c <= hi; c += stride) { - this.appendRange(c, c) + this.appendRange(c, c); } } - return this + return this; } // appendNegatedTable() returns the result of appending the negation of range // table |table| to this CharClass. Does not mutate |table|. appendNegatedTable(table: any): this { - let nextLo = 0 + let nextLo = 0; for (let i = 0; i < table.length; ++i) { - const lo = table.getLo(i) - const hi = table.getHi(i) - const stride = table.getStride(i) + const lo = table.getLo(i); + const hi = table.getHi(i); + const stride = table.getStride(i); if (stride === 1) { if (nextLo <= lo - 1) { - this.appendRange(nextLo, lo - 1) + this.appendRange(nextLo, lo - 1); } - nextLo = hi + 1 - continue + nextLo = hi + 1; + continue; } for (let c = lo; c <= hi; c += stride) { if (nextLo <= c - 1) { - this.appendRange(nextLo, c - 1) + this.appendRange(nextLo, c - 1); } - nextLo = c + 1 + nextLo = c + 1; } } if (nextLo <= Unicode.MAX_RUNE) { - this.appendRange(nextLo, Unicode.MAX_RUNE) + this.appendRange(nextLo, Unicode.MAX_RUNE); } - return this + return this; } // appendTableWithSign() calls append{,Negated}Table depending on sign. // Does not mutate |table|. appendTableWithSign(table: any, sign: number): this { - return sign < 0 ? this.appendNegatedTable(table) : this.appendTable(table) + return sign < 0 ? this.appendNegatedTable(table) : this.appendTable(table); } // negateClass() negates this CharClass, which must already be clean. negateClass(): this { - let nextLo = 0 // lo end of next class to add - let w = 0 // write index + let nextLo = 0; // lo end of next class to add + let w = 0; // write index for (let i = 0; i < this.len; i += 2) { - const lo = this.r[i] - const hi = this.r[i + 1] + const lo = this.r[i]; + const hi = this.r[i + 1]; if (nextLo <= lo - 1) { - this.r[w] = nextLo - this.r[w + 1] = lo - 1 - w += 2 + this.r[w] = nextLo; + this.r[w + 1] = lo - 1; + w += 2; } - nextLo = hi + 1 + nextLo = hi + 1; } - this.len = w + this.len = w; if (nextLo <= Unicode.MAX_RUNE) { - this.r[this.len++] = nextLo - this.r[this.len++] = Unicode.MAX_RUNE + this.r[this.len++] = nextLo; + this.r[this.len++] = Unicode.MAX_RUNE; } - return this + return this; } // appendClassWithSign() calls appendClass() if sign is +1 or // appendNegatedClass if sign is -1. Does not mutate |x|. appendClassWithSign(x: number[], sign: number): this { - return sign < 0 ? this.appendNegatedClass(x) : this.appendClass(x) + return sign < 0 ? this.appendNegatedClass(x) : this.appendClass(x); } // appendGroup() appends CharGroup |g| to this CharClass, folding iff // |foldCase|. Does not mutate |g|. appendGroup(g: any, foldCase: boolean): this { - let cls = g.cls + let cls = g.cls; if (foldCase) { - cls = new CharClass().appendFoldedClass(cls).cleanClass().toArray() + cls = new CharClass().appendFoldedClass(cls).cleanClass().toArray(); } - return this.appendClassWithSign(cls, g.sign) + return this.appendClassWithSign(cls, g.sign); } } -export { CharClass } +export { CharClass }; diff --git a/packages/re2/src/CharGroup.ts b/packages/re2/src/CharGroup.ts index ef2215b..e97a8db 100644 --- a/packages/re2/src/CharGroup.ts +++ b/packages/re2/src/CharGroup.ts @@ -2,84 +2,84 @@ // ./tools/scripts/make_perl_groups.pl > src/CharGroup.js class CharGroup { - sign: number - cls: number[] + sign: number; + cls: number[]; constructor(sign: number, cls: number[]) { - this.sign = sign - this.cls = cls + this.sign = sign; + this.cls = cls; } } -const code1 = [0x30, 0x39] -const code2 = [0x9, 0xa, 0xc, 0xd, 0x20, 0x20] -const code3 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a] +const code1 = [0x30, 0x39]; +const code2 = [0x9, 0xa, 0xc, 0xd, 0x20, 0x20]; +const code3 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a]; -let _PERL_GROUPS: Map | null = null +let _PERL_GROUPS: Map | null = null; const getPerlGroups = (): Map => { if (!_PERL_GROUPS) { _PERL_GROUPS = new Map([ - ['\\d', new CharGroup(+1, code1)], - ['\\D', new CharGroup(-1, code1)], - ['\\s', new CharGroup(+1, code2)], - ['\\S', new CharGroup(-1, code2)], - ['\\w', new CharGroup(+1, code3)], - ['\\W', new CharGroup(-1, code3)] - ]) + ["\\d", new CharGroup(+1, code1)], + ["\\D", new CharGroup(-1, code1)], + ["\\s", new CharGroup(+1, code2)], + ["\\S", new CharGroup(-1, code2)], + ["\\w", new CharGroup(+1, code3)], + ["\\W", new CharGroup(-1, code3)], + ]); } - return _PERL_GROUPS -} + return _PERL_GROUPS; +}; -const code4 = [0x30, 0x39, 0x41, 0x5a, 0x61, 0x7a] -const code5 = [0x41, 0x5a, 0x61, 0x7a] -const code6 = [0x0, 0x7f] -const code7 = [0x9, 0x9, 0x20, 0x20] -const code8 = [0x0, 0x1f, 0x7f, 0x7f] -const code9 = [0x30, 0x39] -const code10 = [0x21, 0x7e] -const code11 = [0x61, 0x7a] -const code12 = [0x20, 0x7e] -const code13 = [0x21, 0x2f, 0x3a, 0x40, 0x5b, 0x60, 0x7b, 0x7e] -const code14 = [0x9, 0xd, 0x20, 0x20] -const code15 = [0x41, 0x5a] -const code16 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a] -const code17 = [0x30, 0x39, 0x41, 0x46, 0x61, 0x66] +const code4 = [0x30, 0x39, 0x41, 0x5a, 0x61, 0x7a]; +const code5 = [0x41, 0x5a, 0x61, 0x7a]; +const code6 = [0x0, 0x7f]; +const code7 = [0x9, 0x9, 0x20, 0x20]; +const code8 = [0x0, 0x1f, 0x7f, 0x7f]; +const code9 = [0x30, 0x39]; +const code10 = [0x21, 0x7e]; +const code11 = [0x61, 0x7a]; +const code12 = [0x20, 0x7e]; +const code13 = [0x21, 0x2f, 0x3a, 0x40, 0x5b, 0x60, 0x7b, 0x7e]; +const code14 = [0x9, 0xd, 0x20, 0x20]; +const code15 = [0x41, 0x5a]; +const code16 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a]; +const code17 = [0x30, 0x39, 0x41, 0x46, 0x61, 0x66]; -let _POSIX_GROUPS: Map | null = null +let _POSIX_GROUPS: Map | null = null; const getPosixGroups = (): Map => { if (!_POSIX_GROUPS) { _POSIX_GROUPS = new Map([ - ['[:alnum:]', new CharGroup(+1, code4)], - ['[:^alnum:]', new CharGroup(-1, code4)], - ['[:alpha:]', new CharGroup(+1, code5)], - ['[:^alpha:]', new CharGroup(-1, code5)], - ['[:ascii:]', new CharGroup(+1, code6)], - ['[:^ascii:]', new CharGroup(-1, code6)], - ['[:blank:]', new CharGroup(+1, code7)], - ['[:^blank:]', new CharGroup(-1, code7)], - ['[:cntrl:]', new CharGroup(+1, code8)], - ['[:^cntrl:]', new CharGroup(-1, code8)], - ['[:digit:]', new CharGroup(+1, code9)], - ['[:^digit:]', new CharGroup(-1, code9)], - ['[:graph:]', new CharGroup(+1, code10)], - ['[:^graph:]', new CharGroup(-1, code10)], - ['[:lower:]', new CharGroup(+1, code11)], - ['[:^lower:]', new CharGroup(-1, code11)], - ['[:print:]', new CharGroup(+1, code12)], - ['[:^print:]', new CharGroup(-1, code12)], - ['[:punct:]', new CharGroup(+1, code13)], - ['[:^punct:]', new CharGroup(-1, code13)], - ['[:space:]', new CharGroup(+1, code14)], - ['[:^space:]', new CharGroup(-1, code14)], - ['[:upper:]', new CharGroup(+1, code15)], - ['[:^upper:]', new CharGroup(-1, code15)], - ['[:word:]', new CharGroup(+1, code16)], - ['[:^word:]', new CharGroup(-1, code16)], - ['[:xdigit:]', new CharGroup(+1, code17)], - ['[:^xdigit:]', new CharGroup(-1, code17)] - ]) + ["[:alnum:]", new CharGroup(+1, code4)], + ["[:^alnum:]", new CharGroup(-1, code4)], + ["[:alpha:]", new CharGroup(+1, code5)], + ["[:^alpha:]", new CharGroup(-1, code5)], + ["[:ascii:]", new CharGroup(+1, code6)], + ["[:^ascii:]", new CharGroup(-1, code6)], + ["[:blank:]", new CharGroup(+1, code7)], + ["[:^blank:]", new CharGroup(-1, code7)], + ["[:cntrl:]", new CharGroup(+1, code8)], + ["[:^cntrl:]", new CharGroup(-1, code8)], + ["[:digit:]", new CharGroup(+1, code9)], + ["[:^digit:]", new CharGroup(-1, code9)], + ["[:graph:]", new CharGroup(+1, code10)], + ["[:^graph:]", new CharGroup(-1, code10)], + ["[:lower:]", new CharGroup(+1, code11)], + ["[:^lower:]", new CharGroup(-1, code11)], + ["[:print:]", new CharGroup(+1, code12)], + ["[:^print:]", new CharGroup(-1, code12)], + ["[:punct:]", new CharGroup(+1, code13)], + ["[:^punct:]", new CharGroup(-1, code13)], + ["[:space:]", new CharGroup(+1, code14)], + ["[:^space:]", new CharGroup(-1, code14)], + ["[:upper:]", new CharGroup(+1, code15)], + ["[:^upper:]", new CharGroup(-1, code15)], + ["[:word:]", new CharGroup(+1, code16)], + ["[:^word:]", new CharGroup(-1, code16)], + ["[:xdigit:]", new CharGroup(+1, code17)], + ["[:^xdigit:]", new CharGroup(-1, code17)], + ]); } - return _POSIX_GROUPS -} + return _POSIX_GROUPS; +}; -export { CharGroup, getPerlGroups, getPosixGroups } +export { CharGroup, getPerlGroups, getPosixGroups }; diff --git a/packages/re2/src/Codepoint.ts b/packages/re2/src/Codepoint.ts index ad31b66..ff718cb 100644 --- a/packages/re2/src/Codepoint.ts +++ b/packages/re2/src/Codepoint.ts @@ -1,58 +1,56 @@ /** * Various constants and helper for unicode codepoints. */ -const ASCII_SIZE = 128 -let _ASCII_TO_UPPER: Int32Array | null = null -let _ASCII_TO_LOWER: Int32Array | null = null +const ASCII_SIZE = 128; +let _ASCII_TO_UPPER: Int32Array | null = null; +let _ASCII_TO_LOWER: Int32Array | null = null; const getAsciiToUpper = (): Int32Array => { if (!_ASCII_TO_UPPER) { - _ASCII_TO_UPPER = new Int32Array(ASCII_SIZE) + _ASCII_TO_UPPER = new Int32Array(ASCII_SIZE); for (let i = 0; i < ASCII_SIZE; i++) { - _ASCII_TO_UPPER[i] = i >= 97 && i <= 122 ? i - 32 : i + _ASCII_TO_UPPER[i] = i >= 97 && i <= 122 ? i - 32 : i; } } - return _ASCII_TO_UPPER -} + return _ASCII_TO_UPPER; +}; const getAsciiToLower = (): Int32Array => { if (!_ASCII_TO_LOWER) { - _ASCII_TO_LOWER = new Int32Array(ASCII_SIZE) + _ASCII_TO_LOWER = new Int32Array(ASCII_SIZE); for (let i = 0; i < ASCII_SIZE; i++) { - _ASCII_TO_LOWER[i] = i >= 65 && i <= 90 ? i + 32 : i + _ASCII_TO_LOWER[i] = i >= 65 && i <= 90 ? i + 32 : i; } } - return _ASCII_TO_LOWER -} + return _ASCII_TO_LOWER; +}; -class Codepoint { - static toUpperCase(codepoint: number): number { - if (codepoint < ASCII_SIZE) return getAsciiToUpper()[codepoint] +function toUpperCase(codepoint: number): number { + if (codepoint < ASCII_SIZE) return getAsciiToUpper()[codepoint]; - const s = String.fromCodePoint(codepoint).toUpperCase() - if (s.length > 1) { - return codepoint - } - const sOrigin = String.fromCodePoint(s.codePointAt(0)!).toLowerCase() - if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) { - return codepoint - } - return s.codePointAt(0)! + const s = String.fromCodePoint(codepoint).toUpperCase(); + if (s.length > 1) { + return codepoint; + } + const sOrigin = String.fromCodePoint(s.codePointAt(0)).toLowerCase(); + if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) { + return codepoint; } + return s.codePointAt(0); +} - static toLowerCase(codepoint: number): number { - if (codepoint < ASCII_SIZE) return getAsciiToLower()[codepoint] +function toLowerCase(codepoint: number): number { + if (codepoint < ASCII_SIZE) return getAsciiToLower()[codepoint]; - const s = String.fromCodePoint(codepoint).toLowerCase() - if (s.length > 1) { - return codepoint - } - const sOrigin = String.fromCodePoint(s.codePointAt(0)!).toUpperCase() - if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) { - return codepoint - } - return s.codePointAt(0)! + const s = String.fromCodePoint(codepoint).toLowerCase(); + if (s.length > 1) { + return codepoint; + } + const sOrigin = String.fromCodePoint(s.codePointAt(0)).toUpperCase(); + if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) { + return codepoint; } + return s.codePointAt(0); } -export { Codepoint } +export { toUpperCase, toLowerCase }; diff --git a/packages/re2/src/Compiler.ts b/packages/re2/src/Compiler.ts index 1ae826e..723b5cf 100644 --- a/packages/re2/src/Compiler.ts +++ b/packages/re2/src/Compiler.ts @@ -1,10 +1,10 @@ -import { RE2Flags } from './RE2Flags.js' -import { Unicode } from './Unicode.js' -import { Utils } from './Utils.js' -import { Regexp } from './Regexp.js' -import { Inst } from './Inst.js' -import { Prog, PatchList } from './Prog.js' -import { RE2JSCompileException } from './exceptions.js' +import { RE2Flags } from "./RE2Flags.js"; +import { Unicode } from "./Unicode.js"; +import { Utils } from "./Utils.js"; +import { Regexp } from "./Regexp.js"; +import { Inst } from "./Inst.js"; +import { Prog, PatchList } from "./Prog.js"; +import { RE2JSCompileException } from "./exceptions.js"; /** * A fragment of a compiled regular expression program. @@ -13,131 +13,132 @@ import { RE2JSCompileException } from './exceptions.js' * @class */ class Frag { - i: number - out: any - nullable: boolean + i: number; + out: PatchList; + nullable: boolean; - constructor(i = 0, out: PatchList | number = new PatchList(), nullable = false) { - this.i = i // an instruction address (pc). - this.out = out // a patch list; see explanation in Prog.js - this.nullable = nullable // whether the fragment can match the empty string + constructor(i = 0, out: PatchList = new PatchList(), nullable = false) { + this.i = i; // an instruction address (pc). + this.out = out; // a patch list; see explanation in Prog.js + this.nullable = nullable; // whether the fragment can match the empty string } } + /** * Compiler from {@code Regexp} (RE2 abstract syntax) to {@code RE2} (compiled regular expression). * * The only entry point is {@link #compileRegexp}. */ class Compiler { - prog: any + prog: Prog; static ANY_RUNE_NOT_NL(): number[] { - return [0, 0x0a - 1, 0x0a + 1, Unicode.MAX_RUNE] + return [0, 0x0a - 1, 0x0a + 1, Unicode.MAX_RUNE]; } static ANY_RUNE(): number[] { - return [0, Unicode.MAX_RUNE] + return [0, Unicode.MAX_RUNE]; } static compileRegexp(re: Regexp): Prog { - const c = new Compiler() - const f = c.compile(re) - c.prog.patch(f.out, c.newInst(Inst.MATCH).i) - c.prog.start = f.i - return c.prog + const c = new Compiler(); + const f = c.compile(re); + c.prog.patch(f.out, c.newInst(Inst.MATCH).i); + c.prog.start = f.i; + return c.prog; } static compileSet(regexps: Regexp[]): Prog { - const c = new Compiler() + const c = new Compiler(); if (regexps.length === 0) { - c.prog.start = c.newInst(Inst.FAIL).i - return c.prog + c.prog.start = c.newInst(Inst.FAIL).i; + return c.prog; } - let starts = [] + let starts = []; for (let i = 0; i < regexps.length; i++) { - const f = c.compile(regexps[i]) - const m = c.newInst(Inst.MATCH) - c.prog.getInst(m.i).arg = i // Store the regex index - c.prog.patch(f.out, m.i) - starts.push(f.i) + const f = c.compile(regexps[i]); + const m = c.newInst(Inst.MATCH); + c.prog.getInst(m.i).arg = i; // Store the regex index + c.prog.patch(f.out, m.i); + starts.push(f.i); } // Link starts together via ALT - let start = starts[0] + let start = starts[0]; for (let i = 1; i < starts.length; i++) { - const f = c.newInst(Inst.ALT) - const inst = c.prog.getInst(f.i) - inst.out = start - inst.arg = starts[i] - start = f.i + const f = c.newInst(Inst.ALT); + const inst = c.prog.getInst(f.i); + inst.out = start; + inst.arg = starts[i]; + start = f.i; } - c.prog.start = start - return c.prog + c.prog.start = start; + return c.prog; } constructor() { - this.prog = new Prog() - this.newInst(Inst.FAIL) + this.prog = new Prog(); + this.newInst(Inst.FAIL); } newInst(op: number): Frag { - this.prog.addInst(op) - return new Frag(this.prog.numInst() - 1, 0, true) + this.prog.addInst(op); + return new Frag(this.prog.numInst() - 1, new PatchList(), true); } // Returns a no-op fragment. Sometimes unavoidable. nop(): Frag { - const f = this.newInst(Inst.NOP) - f.out = new PatchList(f.i << 1, f.i << 1) - return f + const f = this.newInst(Inst.NOP); + f.out = new PatchList(f.i << 1, f.i << 1); + return f; } fail(): Frag { - return new Frag() + return new Frag(); } // Given fragment a, returns (a) capturing as \n. // Given a fragment a, returns a fragment with capturing parens around a. cap(arg: number): Frag { - const f = this.newInst(Inst.CAPTURE) - f.out = new PatchList(f.i << 1, f.i << 1) - this.prog.getInst(f.i).arg = arg + const f = this.newInst(Inst.CAPTURE); + f.out = new PatchList(f.i << 1, f.i << 1); + this.prog.getInst(f.i).arg = arg; if (this.prog.numCap < arg + 1) { - this.prog.numCap = arg + 1 + this.prog.numCap = arg + 1; } - return f + return f; } // Given fragments a and b, returns ab; a|b cat(f1: Frag, f2: Frag): Frag { // concat of failure is failure if (f1.i === 0 || f2.i === 0) { - return this.fail() + return this.fail(); } // eslint-disable-next-line no-warning-comments // TODO(rsc): elide nop - this.prog.patch(f1.out, f2.i) - return new Frag(f1.i, f2.out, f1.nullable && f2.nullable) + this.prog.patch(f1.out, f2.i); + return new Frag(f1.i, f2.out, f1.nullable && f2.nullable); } // Given fragments for a and b, returns fragment for a|b. alt(f1: Frag, f2: Frag): Frag { // alt of failure is other if (f1.i === 0) { - return f2 + return f2; } if (f2.i === 0) { - return f1 + return f1; } - const f = this.newInst(Inst.ALT) - const i = this.prog.getInst(f.i) - i.out = f1.i - i.arg = f2.i - f.out = this.prog.append(f1.out, f2.out) - f.nullable = f1.nullable || f2.nullable - return f + const f = this.newInst(Inst.ALT); + const i = this.prog.getInst(f.i); + i.out = f1.i; + i.arg = f2.i; + f.out = this.prog.append(f1.out, f2.out); + f.nullable = f1.nullable || f2.nullable; + return f; } // loop returns the fragment for the main loop of a plus or star. @@ -146,74 +147,78 @@ class Compiler { // (When f1 can match an empty string, f1* must be implemented as (f1+)? // to get the priority match order correct.) loop(f1: Frag, nongreedy: boolean): Frag { - const f = this.newInst(Inst.ALT) - const i = this.prog.getInst(f.i) + const f = this.newInst(Inst.ALT); + const i = this.prog.getInst(f.i); if (nongreedy) { - i.arg = f1.i - f.out = new PatchList(f.i << 1, f.i << 1) + i.arg = f1.i; + f.out = new PatchList(f.i << 1, f.i << 1); } else { - i.out = f1.i - f.out = new PatchList((f.i << 1) | 1, (f.i << 1) | 1) + i.out = f1.i; + f.out = new PatchList((f.i << 1) | 1, (f.i << 1) | 1); } - this.prog.patch(f1.out, f.i) - return f + this.prog.patch(f1.out, f.i); + return f; } // Given a fragment for a, returns a fragment for a? or a?? (if nongreedy) quest(f1: Frag, nongreedy: boolean): Frag { - const f = this.newInst(Inst.ALT) - const i = this.prog.getInst(f.i) + const f = this.newInst(Inst.ALT); + const i = this.prog.getInst(f.i); if (nongreedy) { - i.arg = f1.i - f.out = new PatchList(f.i << 1, f.i << 1) + i.arg = f1.i; + f.out = new PatchList(f.i << 1, f.i << 1); } else { - i.out = f1.i - f.out = new PatchList((f.i << 1) | 1, (f.i << 1) | 1) + i.out = f1.i; + f.out = new PatchList((f.i << 1) | 1, (f.i << 1) | 1); } - f.out = this.prog.append(f.out, f1.out) - return f + f.out = this.prog.append(f.out, f1.out); + return f; } // Given a fragment a, returns a fragment for a* or a*? (if nongreedy) star(f1: Frag, nongreedy: boolean): Frag { if (f1.nullable) { - return this.quest(this.plus(f1, nongreedy), nongreedy) + return this.quest(this.plus(f1, nongreedy), nongreedy); } - return this.loop(f1, nongreedy) + return this.loop(f1, nongreedy); } // Given a fragment for a, returns a fragment for a+ or a+? (if nongreedy) plus(f1: Frag, nongreedy: boolean): Frag { - return new Frag(f1.i, this.loop(f1, nongreedy).out, f1.nullable) + return new Frag(f1.i, this.loop(f1, nongreedy).out, f1.nullable); } // op is a bitmask of EMPTY_* flags. empty(op: number): Frag { - const f = this.newInst(Inst.EMPTY_WIDTH) - this.prog.getInst(f.i).arg = op - f.out = new PatchList(f.i << 1, f.i << 1) - return f + const f = this.newInst(Inst.EMPTY_WIDTH); + this.prog.getInst(f.i).arg = op; + f.out = new PatchList(f.i << 1, f.i << 1); + return f; } // flags : parser flags rune(runes: number[], flags: number): Frag { - const f = this.newInst(Inst.RUNE) - f.nullable = false - const i = this.prog.getInst(f.i) - i.runes = runes - flags &= RE2Flags.FOLD_CASE + const f = this.newInst(Inst.RUNE); + f.nullable = false; + const i = this.prog.getInst(f.i); + i.runes = runes; + flags &= RE2Flags.FOLD_CASE; if (runes.length !== 1 || Unicode.simpleFold(runes[0]) === runes[0]) { - flags &= ~RE2Flags.FOLD_CASE + flags &= ~RE2Flags.FOLD_CASE; } - i.arg = flags - f.out = new PatchList(f.i << 1, f.i << 1) + i.arg = flags; + f.out = new PatchList(f.i << 1, f.i << 1); if ( ((flags & RE2Flags.FOLD_CASE) === 0 && runes.length === 1) || (runes.length === 2 && runes[0] === runes[1]) ) { - i.op = Inst.RUNE1 - } else if (runes.length === 2 && runes[0] === 0 && runes[1] === Unicode.MAX_RUNE) { - i.op = Inst.RUNE_ANY + i.op = Inst.RUNE1; + } else if ( + runes.length === 2 && + runes[0] === 0 && + runes[1] === Unicode.MAX_RUNE + ) { + i.op = Inst.RUNE_ANY; } else if ( runes.length === 4 && runes[0] === 0 && @@ -221,86 +226,99 @@ class Compiler { runes[2] === 0x0a + 1 && runes[3] === Unicode.MAX_RUNE ) { - i.op = Inst.RUNE_ANY_NOT_NL + i.op = Inst.RUNE_ANY_NOT_NL; } - return f + return f; } compile(re: Regexp): Frag { switch (re.op) { case Regexp.Op.NO_MATCH: - return this.fail() + return this.fail(); case Regexp.Op.EMPTY_MATCH: - return this.nop() + return this.nop(); case Regexp.Op.LITERAL: if (re.runes.length === 0) { - return this.nop() + return this.nop(); } else { - let f: Frag | null = null + let f: Frag | null = null; for (let r of re.runes) { - const f1 = this.rune([r], re.flags) - f = f === null ? f1 : this.cat(f, f1) + const f1 = this.rune([r], re.flags); + f = f === null ? f1 : this.cat(f, f1); } - return f! + return f!; } case Regexp.Op.CHAR_CLASS: - return this.rune(re.runes, re.flags) + return this.rune(re.runes, re.flags); case Regexp.Op.ANY_CHAR_NOT_NL: - return this.rune(Compiler.ANY_RUNE_NOT_NL(), 0) + return this.rune(Compiler.ANY_RUNE_NOT_NL(), 0); case Regexp.Op.ANY_CHAR: - return this.rune(Compiler.ANY_RUNE(), 0) + return this.rune(Compiler.ANY_RUNE(), 0); case Regexp.Op.BEGIN_LINE: - return this.empty(Utils.EMPTY_BEGIN_LINE) + return this.empty(Utils.EMPTY_BEGIN_LINE); case Regexp.Op.END_LINE: - return this.empty(Utils.EMPTY_END_LINE) + return this.empty(Utils.EMPTY_END_LINE); case Regexp.Op.BEGIN_TEXT: - return this.empty(Utils.EMPTY_BEGIN_TEXT) + return this.empty(Utils.EMPTY_BEGIN_TEXT); case Regexp.Op.END_TEXT: - return this.empty(Utils.EMPTY_END_TEXT) + return this.empty(Utils.EMPTY_END_TEXT); case Regexp.Op.WORD_BOUNDARY: - return this.empty(Utils.EMPTY_WORD_BOUNDARY) + return this.empty(Utils.EMPTY_WORD_BOUNDARY); case Regexp.Op.NO_WORD_BOUNDARY: - return this.empty(Utils.EMPTY_NO_WORD_BOUNDARY) + return this.empty(Utils.EMPTY_NO_WORD_BOUNDARY); case Regexp.Op.CAPTURE: { - const bra = this.cap(re.cap << 1) - const sub = this.compile(re.subs[0]) - const ket = this.cap((re.cap << 1) | 1) - return this.cat(this.cat(bra, sub), ket) + const bra = this.cap(re.cap << 1); + const sub = this.compile(re.subs[0]); + const ket = this.cap((re.cap << 1) | 1); + return this.cat(this.cat(bra, sub), ket); } case Regexp.Op.STAR: - return this.star(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0) + return this.star( + this.compile(re.subs[0]), + (re.flags & RE2Flags.NON_GREEDY) !== 0, + ); case Regexp.Op.PLUS: - return this.plus(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0) + return this.plus( + this.compile(re.subs[0]), + (re.flags & RE2Flags.NON_GREEDY) !== 0, + ); case Regexp.Op.QUEST: - return this.quest(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0) + return this.quest( + this.compile(re.subs[0]), + (re.flags & RE2Flags.NON_GREEDY) !== 0, + ); case Regexp.Op.CONCAT: { if (re.subs.length === 0) { - return this.nop() - } else { - let f: Frag | null = null - for (let sub of re.subs) { - const f1 = this.compile(sub) - f = f === null ? f1 : this.cat(f, f1) - } - return f! + return this.nop(); } + let f: Frag | null = null; + for (let sub of re.subs) { + const f1 = this.compile(sub); + f = f === null ? f1 : this.cat(f, f1); + } + if (f === null) { + throw new Error("invalid frag"); + } + return f; } case Regexp.Op.ALTERNATE: { if (re.subs.length === 0) { - return this.nop() - } else { - let f: Frag | null = null - for (let sub of re.subs) { - const f1 = this.compile(sub) - f = f === null ? f1 : this.alt(f, f1) - } - return f! + return this.nop(); + } + let f: Frag | null = null; + for (let sub of re.subs) { + const f1 = this.compile(sub); + f = f === null ? f1 : this.alt(f, f1); + } + if (f === null) { + throw new Error("invalid frag"); } + return f; } default: - throw new RE2JSCompileException('regexp: unhandled case in compile') + throw new RE2JSCompileException("regexp: unhandled case in compile"); } } } -export { Compiler } +export { Compiler }; diff --git a/packages/re2/src/DFA.ts b/packages/re2/src/DFA.ts index 8cfc118..951fba0 100644 --- a/packages/re2/src/DFA.ts +++ b/packages/re2/src/DFA.ts @@ -1,340 +1,364 @@ -import { Inst } from './Inst.js' -import { RE2Flags } from './RE2Flags.js' -import { Unicode } from './Unicode.js' -import { Utils } from './Utils.js' +import { Inst } from "./Inst.js"; +import { RE2Flags } from "./RE2Flags.js"; +import { Unicode } from "./Unicode.js"; +import { Utils } from "./Utils.js"; +import type { Prog } from "./Prog.js"; // FNV-1a 32-bit hash for an array of integers. const hashPCs = (pcs: Int32Array): number => { - let h = -2128831035 + let h = -2128831035; for (let i = 0; i < pcs.length; i++) { - h ^= pcs[i] - h = Math.imul(h, 16777619) + h ^= pcs[i]; + h = Math.imul(h, 16777619); } - return h -} + return h; +}; const arraysEqual = (a: Int32Array, b: Int32Array): boolean => { - if (a.length !== b.length) return false + if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) { - if (a[i] !== b[i]) return false + if (a[i] !== b[i]) return false; } - return true -} + return true; +}; class DFAState { - nfaStates: any - isMatch: boolean - hasEmptyWidth: boolean - matchIDs: number[] - nextAscii: any[] - nextMap: Map + nfaStates: Int32Array; + isMatch: boolean; + hasEmptyWidth: boolean; + matchIDs: number[]; + nextAscii: any[]; + nextMap: Map; constructor( nfaStates: Int32Array, isMatch: boolean, hasEmptyWidth: boolean, - matchIDs: number[] = [] + matchIDs: number[] = [], ) { - this.nfaStates = nfaStates // Int32Array of Instruction PCs - this.isMatch = isMatch - this.hasEmptyWidth = hasEmptyWidth // true if any PC is an EMPTY_WIDTH instruction - this.matchIDs = matchIDs - this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null) - this.nextMap = new Map() + this.nfaStates = nfaStates; // Int32Array of Instruction PCs + this.isMatch = isMatch; + this.hasEmptyWidth = hasEmptyWidth; // true if any PC is an EMPTY_WIDTH instruction + this.matchIDs = matchIDs; + this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null); + this.nextMap = new Map(); } } class DFA { - prog: any - stateCache: Map - stateCount: number - startState: DFAState | null - stateLimit: number - cacheClears: number - failed: boolean - - static MAX_CACHE_CLEARS = 5 - - constructor(prog: any) { - this.prog = prog - this.stateCache = new Map() - this.stateCount = 0 - this.startState = null - this.stateLimit = 10000 - this.cacheClears = 0 - this.failed = false + prog: Prog; + stateCache: Map; + stateCount: number; + startState: DFAState | null; + stateLimit: number; + cacheClears: number; + failed: boolean; + + static MAX_CACHE_CLEARS = 5; + + constructor(prog: Prog) { + this.prog = prog; + this.stateCache = new Map(); + this.stateCount = 0; + this.startState = null; + this.stateLimit = 10000; + this.cacheClears = 0; + this.failed = false; } // Follows epsilon transitions to find all reachable states without consuming a char. // Stops at EMPTY_WIDTH (includes the PC but does not follow through). computeClosure(pcs: number[]): { - pcs: Int32Array - isMatch: boolean - hasEmptyWidth: boolean - matchIDs: number[] + pcs: Int32Array; + isMatch: boolean; + hasEmptyWidth: boolean; + matchIDs: number[]; } { - const closure = new Set() - const stack = [...pcs] - let isMatch = false - let hasEmptyWidth = false - const matchIDs: number[] = [] + const closure = new Set(); + const stack = [...pcs]; + let isMatch = false; + let hasEmptyWidth = false; + const matchIDs: number[] = []; while (stack.length > 0) { - const pc = stack.pop() - if (closure.has(pc)) continue - closure.add(pc) + const pc = stack.pop(); + if (pc === undefined) { + throw new Error("invalid state"); + } + if (closure.has(pc)) continue; + closure.add(pc); - const inst = this.prog.getInst(pc) + const inst = this.prog.getInst(pc); switch (inst.op) { case Inst.MATCH: - isMatch = true - if (!matchIDs.includes(inst.arg)) matchIDs.push(inst.arg) - break + isMatch = true; + if (!matchIDs.includes(inst.arg)) matchIDs.push(inst.arg); + break; case Inst.ALT: case Inst.ALT_MATCH: - stack.push(inst.out) - stack.push(inst.arg) - break + stack.push(inst.out); + stack.push(inst.arg); + break; case Inst.NOP: case Inst.CAPTURE: - stack.push(inst.out) - break + stack.push(inst.out); + break; case Inst.EMPTY_WIDTH: // Include in state but don't follow through — resolved at step time with context - hasEmptyWidth = true - break + hasEmptyWidth = true; + break; } } - const sortedPCs = Int32Array.from(closure).sort() - matchIDs.sort((a, b) => a - b) - return { pcs: sortedPCs, isMatch, hasEmptyWidth, matchIDs } + const sortedPCs = Int32Array.from(closure).sort(); + matchIDs.sort((a, b) => a - b); + return { pcs: sortedPCs, isMatch, hasEmptyWidth, matchIDs }; } // Resolve EMPTY_WIDTH PCs using the given context. // Returns { resolvedPCs: Set, isMatch: boolean } resolveEmptyWidth( nfaStates: Int32Array, - context: number + context: number, ): { resolvedPCs: Set; isMatch: boolean } { - const resolved = new Set() - const stack: number[] = [] - let isMatch = false + const resolved = new Set(); + const stack: number[] = []; + let isMatch = false; // Start with all PCs in the state for (let i = 0; i < nfaStates.length; i++) { - const pc = nfaStates[i] - const inst = this.prog.getInst(pc) + const pc = nfaStates[i]; + const inst = this.prog.getInst(pc); if (inst.op === Inst.EMPTY_WIDTH) { // Check if context satisfies the empty-width condition if ((inst.arg & ~context) === 0) { - stack.push(inst.out) + stack.push(inst.out); } } else { - resolved.add(pc) + resolved.add(pc); if (inst.op === Inst.MATCH) { - isMatch = true + isMatch = true; } } } // Follow through from resolved EMPTY_WIDTH transitions while (stack.length > 0) { - const pc = stack.pop()! - if (resolved.has(pc)) continue - resolved.add(pc) + const pc = stack.pop(); + if (pc === undefined) { + throw new Error("invalid state"); + } + if (resolved.has(pc)) continue; + resolved.add(pc); - const inst = this.prog.getInst(pc) + const inst = this.prog.getInst(pc); switch (inst.op) { case Inst.MATCH: - isMatch = true - break + isMatch = true; + break; case Inst.ALT: case Inst.ALT_MATCH: - stack.push(inst.out) - stack.push(inst.arg) - break + stack.push(inst.out); + stack.push(inst.arg); + break; case Inst.NOP: case Inst.CAPTURE: - stack.push(inst.out) - break + stack.push(inst.out); + break; case Inst.EMPTY_WIDTH: if ((inst.arg & ~context) === 0) { - stack.push(inst.out) + stack.push(inst.out); } - break + break; } } - return { resolvedPCs: resolved, isMatch } + return { resolvedPCs: resolved, isMatch }; } getState(pcs: number[]): DFAState | null { - const closureResult = this.computeClosure(pcs) + const closureResult = this.computeClosure(pcs); - const sortedPCs = closureResult.pcs - const hash = hashPCs(sortedPCs) + const sortedPCs = closureResult.pcs; + const hash = hashPCs(sortedPCs); - let bucket = this.stateCache.get(hash) + let bucket = this.stateCache.get(hash); if (bucket) { for (let i = 0; i < bucket.length; i++) { - const state = bucket[i] + const state = bucket[i]; if (arraysEqual(state.nfaStates, sortedPCs)) { - return state + return state; } } } else { - bucket = [] - this.stateCache.set(hash, bucket) + bucket = []; + this.stateCache.set(hash, bucket); } - if (this.failed) return null + if (this.failed) return null; if (this.stateCount >= this.stateLimit) { - this.stateCache.clear() - this.stateCount = 0 - this.startState = null - this.cacheClears++ + this.stateCache.clear(); + this.stateCount = 0; + this.startState = null; + this.cacheClears++; if (this.cacheClears >= DFA.MAX_CACHE_CLEARS) { - this.failed = true + this.failed = true; } - return null + return null; } const state = new DFAState( sortedPCs, closureResult.isMatch, closureResult.hasEmptyWidth, - closureResult.matchIDs - ) - bucket.push(state) - this.stateCount++ - return state + closureResult.matchIDs, + ); + bucket.push(state); + this.stateCount++; + return state; } // Compute the next DFA state given a current state, a character, and context. // Context is needed only when the state has EMPTY_WIDTH PCs. - step(state: DFAState, charCode: number, anchor: number, context: number): DFAState | null { + step( + state: DFAState, + charCode: number, + anchor: number, + context: number, + ): DFAState | null { // Cache lookup - let cacheKey + let cacheKey; if (state.hasEmptyWidth) { // Context-dependent: include context in key - cacheKey = charCode * 128 + (context & 0x3f) * 2 + (anchor === RE2Flags.UNANCHORED ? 0 : 1) + cacheKey = + charCode * 128 + + (context & 0x3f) * 2 + + (anchor === RE2Flags.UNANCHORED ? 0 : 1); if (state.nextMap.has(cacheKey)) { - return state.nextMap.get(cacheKey) + return state.nextMap.get(cacheKey); } } else { // Context-independent: use original caching if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) { - const next = state.nextAscii[charCode] + const next = state.nextAscii[charCode]; if (next !== null) { - return next + return next; } } else { - cacheKey = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1) + cacheKey = + charCode + + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1); if (state.nextMap.has(cacheKey)) { - return state.nextMap.get(cacheKey) + return state.nextMap.get(cacheKey); } } } // Determine which PCs to check for RUNE matches - let activePCs + let activePCs; if (state.hasEmptyWidth) { - const { resolvedPCs } = this.resolveEmptyWidth(state.nfaStates, context) - activePCs = resolvedPCs + const { resolvedPCs } = this.resolveEmptyWidth(state.nfaStates, context); + activePCs = resolvedPCs; } else { - activePCs = state.nfaStates + activePCs = state.nfaStates; } // Collect next PCs from RUNE matches - const nextPCs = [] - const iterPCs = activePCs instanceof Set ? activePCs : state.nfaStates + const nextPCs = []; + const iterPCs = activePCs instanceof Set ? activePCs : state.nfaStates; for (const pc of iterPCs) { - const inst = this.prog.getInst(pc) + const inst = this.prog.getInst(pc); if (Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) { - nextPCs.push(inst.out) + nextPCs.push(inst.out); } } if (anchor === RE2Flags.UNANCHORED) { - nextPCs.push(this.prog.start) + nextPCs.push(this.prog.start); } - const nextState = this.getState(nextPCs) + const nextState = this.getState(nextPCs); // Cache the result if (state.hasEmptyWidth) { - state.nextMap.set(cacheKey, nextState) - } else if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) { - state.nextAscii[charCode] = nextState + state.nextMap.set(cacheKey, nextState); + } else if ( + anchor === RE2Flags.UNANCHORED && + charCode <= Unicode.MAX_ASCII + ) { + state.nextAscii[charCode] = nextState; } else { - cacheKey = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1) - state.nextMap.set(cacheKey, nextState) + cacheKey = + charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1); + state.nextMap.set(cacheKey, nextState); } - return nextState + return nextState; } // Check if a state matches after resolving EMPTY_WIDTH with end-of-input context checkEndMatch(state: DFAState, prevRune: number): boolean { - if (state.isMatch) return true - if (!state.hasEmptyWidth) return false + if (state.isMatch) return true; + if (!state.hasEmptyWidth) return false; - const endContext = Utils.emptyOpContext(prevRune, -1) - const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endContext) - return isMatch + const endContext = Utils.emptyOpContext(prevRune, -1); + const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endContext); + return isMatch; } // The hot loop: Execute the Lazy DFA match(input: any, pos: number, anchor: number): boolean | null { if (!this.startState) { - this.startState = this.getState([this.prog.start]) - if (!this.startState) return null + this.startState = this.getState([this.prog.start]); + if (!this.startState) return null; } - const endPos = input.endPos() - let currentState: DFAState | null = this.startState + const endPos = input.endPos(); + let currentState: DFAState | null = this.startState; // prevRune: the rune immediately before position `pos`. For pos=0 this is // -1 (beginning-of-text sentinel). For pos>0 we query the input so that // ^, \A, and \b anchors use the correct context when matching begins // from a mid-text offset. - let prevRune = -1 + let prevRune = -1; if (pos > 0) { - const r = input.step(pos - 1) >> 3 - if (r >= 0) prevRune = r + const r = input.step(pos - 1) >> 3; + if (r >= 0) prevRune = r; } // Check if start state matches directly (e.g., empty pattern) if (currentState.isMatch) { if (anchor === RE2Flags.ANCHOR_BOTH) { - if (pos === endPos) return true + if (pos === endPos) return true; } else { - return true + return true; } } - let i = pos + let i = pos; while (i < endPos) { - const r = input.step(i) - const rune = r >> 3 - const width = r & 7 - if (width === 0) break + const r = input.step(i); + const rune = r >> 3; + const width = r & 7; + if (width === 0) break; // Compute context at position i (between prevRune and rune) - const context = Utils.emptyOpContext(prevRune, rune) + const context = Utils.emptyOpContext(prevRune, rune); // Before consuming: check if EMPTY_WIDTH in current state resolves to MATCH if (currentState.hasEmptyWidth) { - const { isMatch } = this.resolveEmptyWidth(currentState.nfaStates, context) + const { isMatch } = this.resolveEmptyWidth( + currentState.nfaStates, + context, + ); if (isMatch) { if (anchor === RE2Flags.ANCHOR_BOTH) { // Match at position i (before consuming rune) — only valid if i === endPos // which can't happen in this loop, so skip } else { - return true + return true; } } } @@ -346,28 +370,29 @@ class DFA { rune <= Unicode.MAX_ASCII ) { currentState = - currentState.nextAscii[rune] || this.step(currentState, rune, anchor, context) + currentState.nextAscii[rune] || + this.step(currentState, rune, anchor, context); } else { - currentState = this.step(currentState, rune, anchor, context) + currentState = this.step(currentState, rune, anchor, context); } - if (currentState === null) return null + if (currentState === null) return null; // After consuming: check if new state is a match if (currentState.isMatch) { if (anchor === RE2Flags.ANCHOR_BOTH) { - if (i + width === endPos) return true + if (i + width === endPos) return true; } else { - return true + return true; } } if (currentState.nfaStates.length === 0) { - if (anchor !== RE2Flags.UNANCHORED) return false + if (anchor !== RE2Flags.UNANCHORED) return false; } - prevRune = rune - i += width + prevRune = rune; + i += width; } // After the loop: check EMPTY_WIDTH at end of text. @@ -375,78 +400,88 @@ class DFA { // UNANCHORED/ANCHOR_START accept any match; ANCHOR_BOTH accepts it because // we have consumed the entire input up to endPos. if (currentState.hasEmptyWidth) { - const endContext = Utils.emptyOpContext(prevRune, -1) - const { isMatch } = this.resolveEmptyWidth(currentState.nfaStates, endContext) - if (isMatch) return true + const endContext = Utils.emptyOpContext(prevRune, -1); + const { isMatch } = this.resolveEmptyWidth( + currentState.nfaStates, + endContext, + ); + if (isMatch) return true; } - return false + return false; } // Multi-Pattern Set matching (kept for compatibility) matchSet(input: any, pos: number, anchor: number): number[] | null { - if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) { - return [] + if ( + (anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && + pos !== 0 + ) { + return []; } if (!this.startState) { - this.startState = this.getState([this.prog.start]) - if (!this.startState) return null + this.startState = this.getState([this.prog.start]); + if (!this.startState) return null; } - let endPos = input.endPos() - let currentState: DFAState | null = this.startState - let prevRune = -1 - const matches = new Set() + let endPos = input.endPos(); + let currentState: DFAState | null = this.startState; + let prevRune = -1; + const matches = new Set(); - const checkMatch = (state: DFAState, currentPos: number, prevR: number): void => { + const checkMatch = ( + state: DFAState, + currentPos: number, + prevR: number, + ): void => { if (state.isMatch) { if (anchor === RE2Flags.ANCHOR_BOTH) { if (currentPos === endPos) { - state.matchIDs.forEach((id: number) => matches.add(id)) + state.matchIDs.forEach((id: number) => matches.add(id)); } } else { - state.matchIDs.forEach((id: number) => matches.add(id)) + state.matchIDs.forEach((id: number) => matches.add(id)); } } // Also check EMPTY_WIDTH resolution at end if (state.hasEmptyWidth && currentPos === endPos) { - const endCtx = Utils.emptyOpContext(prevR, -1) - const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endCtx) + const endCtx = Utils.emptyOpContext(prevR, -1); + const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endCtx); if (isMatch) { if (anchor === RE2Flags.ANCHOR_BOTH) { - state.matchIDs.forEach((id: number) => matches.add(id)) + state.matchIDs.forEach((id: number) => matches.add(id)); } } } - } + }; - checkMatch(currentState, pos, prevRune) + checkMatch(currentState, pos, prevRune); - let i = pos + let i = pos; while (i < endPos) { - const r = input.step(i) - const rune = r >> 3 - const width = r & 7 + const r = input.step(i); + const rune = r >> 3; + const width = r & 7; - if (width === 0) break + if (width === 0) break; - const context = Utils.emptyOpContext(prevRune, rune) - currentState = this.step(currentState, rune, anchor, context) + const context = Utils.emptyOpContext(prevRune, rune); + currentState = this.step(currentState, rune, anchor, context); - if (currentState === null) return null + if (currentState === null) return null; - prevRune = rune - i += width - checkMatch(currentState, i, prevRune) + prevRune = rune; + i += width; + checkMatch(currentState, i, prevRune); if (currentState.nfaStates.length === 0) { - if (anchor !== RE2Flags.UNANCHORED) break + if (anchor !== RE2Flags.UNANCHORED) break; } } - return Array.from(matches).sort((a, b) => a - b) + return Array.from(matches).sort((a, b) => a - b); } } -export { DFA } +export { DFA }; diff --git a/packages/re2/src/Inst.ts b/packages/re2/src/Inst.ts index d9944b6..321f16a 100644 --- a/packages/re2/src/Inst.ts +++ b/packages/re2/src/Inst.ts @@ -1,39 +1,39 @@ -import { RE2Flags } from './RE2Flags.js' -import { Unicode } from './Unicode.js' +import { RE2Flags } from "./RE2Flags.js"; +import { Unicode } from "./Unicode.js"; /** * A single instruction in the regular expression virtual machine. * * @see http://swtch.com/~rsc/regexp/regexp2.html */ class Inst { - static ALT = 1 - static ALT_MATCH = 2 - static CAPTURE = 3 - static EMPTY_WIDTH = 4 - static FAIL = 5 - static MATCH = 6 - static NOP = 7 - static RUNE = 8 - static RUNE1 = 9 - static RUNE_ANY = 10 - static RUNE_ANY_NOT_NL = 11 + static ALT = 1; + static ALT_MATCH = 2; + static CAPTURE = 3; + static EMPTY_WIDTH = 4; + static FAIL = 5; + static MATCH = 6; + static NOP = 7; + static RUNE = 8; + static RUNE1 = 9; + static RUNE_ANY = 10; + static RUNE_ANY_NOT_NL = 11; - op: number - out: number - arg: number - runes: number[] + op: number; + out: number; + arg: number; + runes: number[]; static isRuneOp(op: number): boolean { - return Inst.RUNE <= op && op <= Inst.RUNE_ANY_NOT_NL + return Inst.RUNE <= op && op <= Inst.RUNE_ANY_NOT_NL; } constructor(op: number) { - this.op = op - this.out = 0 // all but MATCH, FAIL - this.arg = 0 // ALT, ALT_MATCH, CAPTURE, EMPTY_WIDTH + this.op = op; + this.out = 0; // all but MATCH, FAIL + this.arg = 0; // ALT, ALT_MATCH, CAPTURE, EMPTY_WIDTH // length==1 => exact match // otherwise a list of [lo,hi] pairs. hi is *inclusive*. - this.runes = [] + this.runes = []; } // MatchRune returns true if the instruction matches (and consumes) r. @@ -42,49 +42,49 @@ class Inst { // Special case: single-rune slice is from literal string, not char // class. if (this.runes.length === 1) { - const r0 = this.runes[0] + const r0 = this.runes[0]; // If this pattern is case-insensitive, apply Unicode case folding to compare the two runes. // Note that this may result in a case-folding loop when executed, // so attempt to reduce the chance of that occurring // by performing case folding on |r0| from the pattern rather than |r| from the input. if ((this.arg & RE2Flags.FOLD_CASE) !== 0) { - return Unicode.equalsIgnoreCase(r0, r) + return Unicode.equalsIgnoreCase(r0, r); } - return r === r0 + return r === r0; } - const len = this.runes.length + const len = this.runes.length; // If the array is exactly 2, 4, 6, or 8 items, DO NOT fall through to binary search if (len === 2 || len === 4 || len === 6 || len === 8) { for (let j = 0; j < len; j += 2) { if (r < this.runes[j]) { - return false + return false; } if (r <= this.runes[j + 1]) { - return true + return true; } } - return false // Stop here + return false; // Stop here } // Otherwise binary search. - let lo = 0 - let hi = (this.runes.length / 2) | 0 + let lo = 0; + let hi = (this.runes.length / 2) | 0; while (lo < hi) { - const m = (lo + hi) >> 1 // native cpu instruction for "lo + (((hi - lo) / 2) | 0)" - const c = this.runes[2 * m] + const m = (lo + hi) >> 1; // native cpu instruction for "lo + (((hi - lo) / 2) | 0)" + const c = this.runes[2 * m]; if (c <= r) { if (r <= this.runes[2 * m + 1]) { - return true + return true; } - lo = m + 1 + lo = m + 1; } else { - hi = m + hi = m; } } - return false + return false; } } -export { Inst } +export { Inst }; diff --git a/packages/re2/src/MachineInput.ts b/packages/re2/src/MachineInput.ts index 13bda9d..e8c7deb 100644 --- a/packages/re2/src/MachineInput.ts +++ b/packages/re2/src/MachineInput.ts @@ -1,100 +1,91 @@ -import { Utils } from './Utils.js' -import { Unicode } from './Unicode.js' +import { Utils } from "./Utils.js"; +import { Unicode } from "./Unicode.js"; +import type { Prefilter } from "./Prefilter.js"; +import type { RE2 } from "./RE2.js"; -/** - * MachineInput abstracts the input text supplied to the matching engine. - */ -class MachineInputBase { - end!: number +class MachineUTF16Input { + charSequence: string; + start: number; + end!: number; - static EOF(): number { - return -1 << 3 + constructor(charSequence: string, start = 0, end = charSequence.length) { + this.charSequence = charSequence; + this.start = start; + this.end = end; } - canCheckPrefix(): boolean { - return true + static EOF(): number { + return -1 << 3; } endPos(): number { - return this.end + return this.end; } - hasString(prefilter?: any, pos?: number): boolean { - return false - } - - prefixLength(re2?: any): number { - return 0 - } -} - -// |pos| and |width| are in JS "char" units. -class MachineUTF16Input extends MachineInputBase { - charSequence: string - start: number - - constructor(charSequence: string, start = 0, end = charSequence.length) { - super() - this.charSequence = charSequence - this.start = start - this.end = end - } - - override hasString(prefilter: any, pos: number): boolean { - const idx = this.charSequence.indexOf(prefilter.str, this.start + pos) - return idx !== -1 && idx <= this.end - prefilter.str.length + hasString(prefilter: Prefilter, pos: number): boolean { + const idx = this.charSequence.indexOf(prefilter.str, this.start + pos); + return idx !== -1 && idx <= this.end - prefilter.str.length; } step(pos: number): number { - pos += this.start + pos += this.start; if (pos >= this.end) { - return MachineInputBase.EOF() + return MachineUTF16Input.EOF(); } - const c1 = this.charSequence.charCodeAt(pos) + const c1 = this.charSequence.charCodeAt(pos); // Fast path: standard BMP character (not a high surrogate) - if (c1 < Unicode.MIN_HIGH_SURROGATE || c1 > Unicode.MAX_HIGH_SURROGATE || pos + 1 >= this.end) { - return (c1 << 3) | 1 + if ( + c1 < Unicode.MIN_HIGH_SURROGATE || + c1 > Unicode.MAX_HIGH_SURROGATE || + pos + 1 >= this.end + ) { + return (c1 << 3) | 1; } // Slow path: Calculate surrogate pair manually - const c2 = this.charSequence.charCodeAt(pos + 1) + const c2 = this.charSequence.charCodeAt(pos + 1); if (c2 >= Unicode.MIN_LOW_SURROGATE && c2 <= Unicode.MAX_LOW_SURROGATE) { const rune = (c1 - Unicode.MIN_HIGH_SURROGATE) * 0x400 + (c2 - Unicode.MIN_LOW_SURROGATE) + - Unicode.MIN_SUPPLEMENTARY_CODE_POINT - return (rune << 3) | 2 + Unicode.MIN_SUPPLEMENTARY_CODE_POINT; + return (rune << 3) | 2; } // Invalid surrogate pair fallback - return (c1 << 3) | 1 + return (c1 << 3) | 1; } - index(re2: any, pos: number): number { - pos += this.start - const i = this.charSequence.indexOf(re2.prefix, pos) - return i < 0 ? i : i - pos + index(re2: RE2, pos: number): number { + pos += this.start; + const i = this.charSequence.indexOf(re2.prefix, pos); + return i < 0 ? i : i - pos; } context(pos: number): number { - pos += this.start + pos += this.start; const r1 = - pos > 0 && pos <= this.charSequence.length ? this.charSequence.codePointAt(pos - 1)! : -1 - const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos)! : -1 - return Utils.emptyOpContext(r1, r2) + pos > 0 && pos <= this.charSequence.length + ? this.charSequence.codePointAt(pos - 1)! + : -1; + const r2 = + pos < this.charSequence.length ? this.charSequence.codePointAt(pos)! : -1; + return Utils.emptyOpContext(r1, r2); } - override prefixLength(re2: any): number { - return re2.prefix.length + prefixLength(re2: RE2): number { + return re2.prefix.length; } } -class MachineInput { - static fromUTF16(charSequence: string, start = 0, end = charSequence.length): MachineUTF16Input { - return new MachineUTF16Input(charSequence, start, end) - } +function fromUTF16( + charSequence: string, + start = 0, + end = charSequence.length, +): MachineUTF16Input { + return new MachineUTF16Input(charSequence, start, end); } -export { MachineInputBase, MachineInput } +export { fromUTF16, MachineUTF16Input }; diff --git a/packages/re2/src/Parser.ts b/packages/re2/src/Parser.ts index fb6c0ba..82d3998 100644 --- a/packages/re2/src/Parser.ts +++ b/packages/re2/src/Parser.ts @@ -1,12 +1,12 @@ -import { RE2Flags } from './RE2Flags.js' -import { Unicode } from './Unicode.js' -import { UnicodeTables } from './UnicodeTables.js' -import { UnicodeRangeTable } from './UnicodeRangeTable.js' -import { getPerlGroups, getPosixGroups } from './CharGroup.js' -import { Utils } from './Utils.js' -import { CharClass } from './CharClass.js' -import { RE2JSSyntaxException } from './exceptions.js' -import { Regexp } from './Regexp.js' +import { RE2Flags } from "./RE2Flags.js"; +import { Unicode } from "./Unicode.js"; +import { UnicodeTables } from "./UnicodeTables.js"; +import { UnicodeRangeTable } from "./UnicodeRangeTable.js"; +import { getPerlGroups, getPosixGroups } from "./CharGroup.js"; +import { Utils } from "./Utils.js"; +import { CharClass } from "./CharClass.js"; +import { RE2JSSyntaxException } from "./exceptions.js"; +import { Regexp } from "./Regexp.js"; // StringIterator: a stream of runes with an opaque cursor, permitting // rewinding. The units of the cursor are not specified beyond the @@ -21,33 +21,33 @@ import { Regexp } from './Regexp.js' // lookingAt(). // Only use pop() to advance over possibly non-ASCII runes. class StringIterator { - str: string - position: number + str: string; + position: number; constructor(str: string) { - this.str = str - this.position = 0 + this.str = str; + this.position = 0; } // Returns the cursor position. Do not interpret the result! pos(): number { - return this.position + return this.position; } // Resets the cursor position to a previous value returned by pos(). rewindTo(pos: number): void { - this.position = pos + this.position = pos; } // Returns true unless the stream is exhausted. more(): boolean { - return this.position < this.str.length + return this.position < this.str.length; } // Returns the rune at the cursor position. // Precondition: |more()|. peek(): number { - return this.str.codePointAt(this.position)! + return this.str.codePointAt(this.position)!; } // Advances the cursor by |n| positions, which must be ASCII runes. @@ -56,39 +56,39 @@ class StringIterator { // metacharacters that are ASCII, so there is no numeric difference // between indices into UTF-8 bytes, UTF-16 codes and runes.) skip(n: number): void { - this.position += n + this.position += n; } // Advances the cursor by the number of cursor positions in |s|. skipString(s: string): void { - this.position += s.length + this.position += s.length; } // Returns the rune at the cursor position, and advances the cursor // past it. Precondition: |more()|. pop(): number { - const r = this.str.codePointAt(this.position)! - this.position += Utils.charCount(r) - return r + const r = this.str.codePointAt(this.position)!; + this.position += Utils.charCount(r); + return r; } lookingAt(s: string): boolean { - return this.str.startsWith(s, this.position) + return this.str.startsWith(s, this.position); } // Returns the rest of the pattern from the current position. rest(): string { - return this.str.substring(this.position) + return this.str.substring(this.position); } // Returns the substring from |beforePos| to the current position. // |beforePos| must have been previously returned by |pos()|. from(beforePos: number): string { - return this.str.substring(beforePos, this.position) + return this.str.substring(beforePos, this.position); } toString(): string { - return this.rest() + return this.rest(); } } /** @@ -98,23 +98,25 @@ class StringIterator { */ class Parser { // Unexpected error - static ERR_INTERNAL_ERROR = 'regexp/syntax: internal error' + static ERR_INTERNAL_ERROR = "regexp/syntax: internal error"; // Parse errors - static ERR_INVALID_CHAR_RANGE = 'invalid character class range' - static ERR_INVALID_ESCAPE = 'invalid escape sequence' - static ERR_INVALID_NAMED_CAPTURE = 'invalid named capture' - static ERR_INVALID_PERL_OP = 'invalid or unsupported Perl syntax' - static ERR_INVALID_REPEAT_OP = 'invalid nested repetition operator' - static ERR_INVALID_REPEAT_SIZE = 'invalid repeat count' - static ERR_MISSING_BRACKET = 'missing closing ]' - static ERR_MISSING_PAREN = 'missing closing )' - static ERR_MISSING_REPEAT_ARGUMENT = 'missing argument to repetition operator' - static ERR_TRAILING_BACKSLASH = 'trailing backslash at end of expression' - static ERR_DUPLICATE_NAMED_CAPTURE = 'duplicate capture group name' - static ERR_UNEXPECTED_PAREN = 'unexpected )' - static ERR_NESTING_DEPTH = 'expression nests too deeply' - static ERR_LARGE = 'expression too large' + static ERR_INVALID_CHAR_RANGE = "invalid character class range"; + static ERR_INVALID_ESCAPE = "invalid escape sequence"; + static ERR_INVALID_NAMED_CAPTURE = "invalid named capture"; + static ERR_INVALID_PERL_OP = "invalid or unsupported Perl syntax"; + static ERR_INVALID_REPEAT_OP = "invalid nested repetition operator"; + static ERR_INVALID_REPEAT_SIZE = "invalid repeat count"; + static ERR_MISSING_BRACKET = "missing closing ]"; + static ERR_MISSING_PAREN = "missing closing )"; + static ERR_MISSING_REPEAT_ARGUMENT = + "missing argument to repetition operator"; + static ERR_TRAILING_BACKSLASH = "trailing backslash at end of expression"; + static ERR_DUPLICATE_NAMED_CAPTURE = "duplicate capture group name"; + static ERR_UNEXPECTED_PAREN = "unexpected )"; + static ERR_NESTING_DEPTH = "expression nests too deeply"; + static ERR_LARGE = "expression too large"; + static ERR_BAD_EXPRESSION = "expression not valid"; // maxHeight is the maximum height of a regexp parse tree. // It is somewhat arbitrarily chosen, but the idea is to be large enough @@ -128,7 +130,7 @@ class Parser { // Using depth 1000 should be plenty of margin. // As an optimization, we don't even bother calculating heights // until we've allocated at least maxHeight Regexp structures. - static MAX_HEIGHT = 1000 + static MAX_HEIGHT = 1000; // maxSize is the maximum size of a compiled regexp in Insts. // It too is somewhat arbitrarily chosen, but the idea is to be large enough @@ -136,7 +138,7 @@ class Parser { // the compiled form will not take up too much memory. // 128 MB is enough for a 3.3 million Inst structures, which roughly // corresponds to a 3.3 MB regexp. - static MAX_SIZE = 3355443 // 128 << 20 / (5 * 8) (instSize = byte, 2 uint32, slice is 5 64-bit words) + static MAX_SIZE = 3355443; // 128 << 20 / (5 * 8) (instSize = byte, 2 uint32, slice is 5 64-bit words) // maxRunes is the maximum number of runes allowed in a regexp tree // counting the runes in all the nodes. @@ -153,14 +155,16 @@ class Parser { // there is not an opportunity to change the representation to allow // partial sharing between different character classes. // So the limit is the best we can do. - static MAX_RUNES = 33554432 // 128 << 20 / 4 (runeSize, int32 is 4 bytes) + static MAX_RUNES = 33554432; // 128 << 20 / 4 (runeSize, int32 is 4 bytes) // RangeTables are represented as int[][], a list of triples (start, end, // stride). - static ANY_TABLE = new UnicodeRangeTable(new Uint32Array([0, Unicode.MAX_RUNE, 1])) + static ANY_TABLE = new UnicodeRangeTable( + new Uint32Array([0, Unicode.MAX_RUNE, 1]), + ); // Ascii tables - static ASCII_TABLE = new UnicodeRangeTable(new Uint32Array([0, 0x7f, 1])) + static ASCII_TABLE = new UnicodeRangeTable(new Uint32Array([0, 0x7f, 1])); static ASCII_FOLD_TABLE = new UnicodeRangeTable( new Uint32Array([ 0, @@ -171,73 +175,79 @@ class Parser { 1, // Old English long s (ſ), folds to S/s. 0x212a, 0x212a, - 1 // Kelvin K, folds to K/k. - ]) - ) + 1, // Kelvin K, folds to K/k. + ]), + ); // unicodeTable() returns the Unicode RangeTable identified by name // and the table of additional fold-equivalent code points. // Returns null if |name| does not identify a Unicode character range. - static unicodeTable(name: string): { tab: any; fold: any; sign: number } | null { - if (name === 'Any') { - return { tab: Parser.ANY_TABLE, fold: Parser.ANY_TABLE, sign: +1 } + static unicodeTable( + name: string, + ): { tab: any; fold: any; sign: number } | null { + if (name === "Any") { + return { tab: Parser.ANY_TABLE, fold: Parser.ANY_TABLE, sign: +1 }; } - if (name === 'Ascii') { - return { tab: Parser.ASCII_TABLE, fold: Parser.ASCII_FOLD_TABLE, sign: +1 } + if (name === "Ascii") { + return { + tab: Parser.ASCII_TABLE, + fold: Parser.ASCII_FOLD_TABLE, + sign: +1, + }; } - if (name === 'Assigned') { + if (name === "Assigned") { // Assigned is the mathematical inversion of Cn (Unassigned) return { - tab: UnicodeTables.CATEGORIES.get('Cn'), - fold: UnicodeTables.CATEGORIES.get('Cn'), - sign: -1 - } + tab: UnicodeTables.CATEGORIES.get("Cn"), + fold: UnicodeTables.CATEGORIES.get("Cn"), + sign: -1, + }; } - if (name === 'Lc') { + if (name === "Lc") { return { - tab: UnicodeTables.CATEGORIES.get('LC'), - fold: UnicodeTables.FOLD_CATEGORIES.get('LC'), - sign: +1 - } + tab: UnicodeTables.CATEGORIES.get("LC"), + fold: UnicodeTables.FOLD_CATEGORIES.get("LC"), + sign: +1, + }; } if (UnicodeTables.CATEGORIES.has(name)) { return { tab: UnicodeTables.CATEGORIES.get(name), fold: UnicodeTables.FOLD_CATEGORIES.get(name), - sign: +1 - } + sign: +1, + }; } if (UnicodeTables.SCRIPTS.has(name)) { return { tab: UnicodeTables.SCRIPTS.get(name), fold: UnicodeTables.FOLD_SCRIPT.get(name), - sign: +1 - } + sign: +1, + }; } - return null + return null; } // minFoldRune returns the minimum rune fold-equivalent to r. static minFoldRune(r: number): number { if (r < Unicode.MIN_FOLD || r > Unicode.MAX_FOLD) { - return r + return r; } - let min = r - const r0 = r + let min = r; + const r0 = r; for (r = Unicode.simpleFold(r); r !== r0; r = Unicode.simpleFold(r)) { if (min > r) { - min = r + min = r; } } - return min + return min; } static literalRegexp(s: string, flags: number): Regexp { - const re = new Regexp(Regexp.Op.LITERAL) - re.flags = flags - re.runes = Utils.stringToRunes(s) as number[] - return re + const re = new Regexp(Regexp.Op.LITERAL); + re.flags = flags; + re.runes = Utils.stringToRunes(s) as number[]; + return re; } /** * Parse regular expression pattern {@code pattern} with mode flags {@code flags}. @@ -245,7 +255,7 @@ class Parser { * @param {number} flags */ static parse(pattern: string, flags: number): Regexp { - return new Parser(pattern, flags).parseInternal() + return new Parser(pattern, flags).parseInternal(); } // parseRepeat parses {min} (max=min) or {min,} (max=-1) or {min,max}. @@ -259,44 +269,53 @@ class Parser { // On success, advances |t| beyond the repeat; otherwise |t.pos()| is // undefined. static parseRepeat(t: StringIterator): number { - const start = t.pos() - if (!t.more() || !t.lookingAt('{')) { - return -1 + const start = t.pos(); + if (!t.more() || !t.lookingAt("{")) { + return -1; } - t.skip(1) + t.skip(1); - const min = Parser.parseInt(t) + const min = Parser.parseInt(t); if (min === -1) { - return -1 + return -1; } if (!t.more()) { - return -1 + return -1; } - let max - if (!t.lookingAt(',')) { - max = min + let max; + if (!t.lookingAt(",")) { + max = min; } else { - t.skip(1) + t.skip(1); if (!t.more()) { - return -1 + return -1; } - if (t.lookingAt('}')) { - max = -1 + if (t.lookingAt("}")) { + max = -1; } else if ((max = Parser.parseInt(t)) === -1) { - return -1 + return -1; } } - if (!t.more() || !t.lookingAt('}')) { - return -1 + if (!t.more() || !t.lookingAt("}")) { + return -1; } - t.skip(1) - if (min < 0 || min > 1000 || max === -2 || max > 1000 || (max >= 0 && min > max)) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_SIZE, t.from(start)) + t.skip(1); + if ( + min < 0 || + min > 1000 || + max === -2 || + max > 1000 || + (max >= 0 && min > max) + ) { + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_REPEAT_SIZE, + t.from(start), + ); } - return (min << 16) | (max & Unicode.MAX_BMP) + return (min << 16) | (max & Unicode.MAX_BMP); } // isValidCaptureName reports whether name @@ -306,35 +325,35 @@ class Parser { // We don't enforce either of those. static isValidCaptureName(name: string): boolean { if (name.length === 0) { - return false + return false; } for (let i = 0; i < name.length; i++) { - const c = name.codePointAt(i)! + const c = name.codePointAt(i)!; if (c !== 0x5f && !Utils.isalnum(c)) { - return false + return false; } } - return true + return true; } // parseInt parses a nonnegative decimal integer. // -1 => bad format. -2 => format ok, but integer overflow. static parseInt(t: StringIterator): number { - const start = t.pos() + const start = t.pos(); while (t.more() && t.peek()! >= 0x30 && t.peek()! <= 0x39) { - t.skip(1) + t.skip(1); } - const n = t.from(start) + const n = t.from(start); if (n.length === 0 || (n.length > 1 && n.codePointAt(0) === 0x30)) { - return -1 + return -1; } if (n.length > 8) { - return -2 + return -2; } - return parseInt(n, 10) + return parseInt(n, 10); } // can this be represented as a character class? @@ -345,27 +364,27 @@ class Parser { re.op === Regexp.Op.CHAR_CLASS || re.op === Regexp.Op.ANY_CHAR_NOT_NL || re.op === Regexp.Op.ANY_CHAR - ) + ); } // does re match r? static matchRune(re: Regexp, r: number): boolean { switch (re.op) { case Regexp.Op.LITERAL: - return re.runes.length === 1 && re.runes[0] === r + return re.runes.length === 1 && re.runes[0] === r; case Regexp.Op.CHAR_CLASS: for (let i = 0; i < re.runes.length; i += 2) { if (re.runes[i] <= r && r <= re.runes[i + 1]) { - return true + return true; } } - return false + return false; case Regexp.Op.ANY_CHAR_NOT_NL: - return r !== 0x0a + return r !== 0x0a; case Regexp.Op.ANY_CHAR: - return true + return true; } - return false + return false; } // mergeCharClass makes dst = dst|src. @@ -374,29 +393,31 @@ class Parser { static mergeCharClass(dst: Regexp, src: Regexp): void { switch (dst.op) { case Regexp.Op.ANY_CHAR: - break + break; case Regexp.Op.ANY_CHAR_NOT_NL: if (Parser.matchRune(src, 0x0a)) { - dst.op = Regexp.Op.ANY_CHAR + dst.op = Regexp.Op.ANY_CHAR; } - break + break; case Regexp.Op.CHAR_CLASS: if (src.op === Regexp.Op.LITERAL) { - dst.runes = new CharClass(dst.runes).appendLiteral(src.runes[0], src.flags).toArray() + dst.runes = new CharClass(dst.runes) + .appendLiteral(src.runes[0], src.flags) + .toArray(); } else { - dst.runes = new CharClass(dst.runes).appendClass(src.runes).toArray() + dst.runes = new CharClass(dst.runes).appendClass(src.runes).toArray(); } - break + break; case Regexp.Op.LITERAL: if (src.runes[0] === dst.runes[0] && src.flags === dst.flags) { - break + break; } - dst.op = Regexp.Op.CHAR_CLASS + dst.op = Regexp.Op.CHAR_CLASS; dst.runes = new CharClass() .appendLiteral(dst.runes[0], dst.flags) .appendLiteral(src.runes[0], src.flags) - .toArray() - break + .toArray(); + break; } } @@ -404,12 +425,12 @@ class Parser { // and returns the rune. // Pre: t at '\\'. Post: after escape. static parseEscape(t: StringIterator): number { - const startPos = t.pos() - t.skip(1) // '\\' + const startPos = t.pos(); + t.skip(1); // '\\' if (!t.more()) { - throw new RE2JSSyntaxException(Parser.ERR_TRAILING_BACKSLASH) + throw new RE2JSSyntaxException(Parser.ERR_TRAILING_BACKSLASH); } - let c = t.pop() + let c = t.pop(); bigswitch: switch (c) { case 0x31: case 0x32: @@ -420,80 +441,80 @@ class Parser { case 0x30: case 0x37: { if (c !== 0x30 && (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37)) { - break + break; } - let r = c - 0x30 + let r = c - 0x30; for (let i = 1; i < 3; i++) { if (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37) { - break + break; } - r = r * 8 + t.peek()! - 0x30 - t.skip(1) + r = r * 8 + t.peek()! - 0x30; + t.skip(1); } - return r + return r; } case 0x78: { if (!t.more()) { - break + break; } - c = t.pop() + c = t.pop(); if (c === 0x7b) { - let nhex = 0 - let r = 0 + let nhex = 0; + let r = 0; while (true) { if (!t.more()) { - break bigswitch + break bigswitch; } - c = t.pop() + c = t.pop(); if (c === 0x7d) { - break + break; } - const v = Utils.unhex(c) + const v = Utils.unhex(c); if (v < 0) { - break bigswitch + break bigswitch; } - r = r * 16 + v + r = r * 16 + v; if (r > Unicode.MAX_RUNE) { - break bigswitch + break bigswitch; } - nhex++ + nhex++; } if (nhex === 0) { - break bigswitch + break bigswitch; } - return r + return r; } - const x = Utils.unhex(c) + const x = Utils.unhex(c); if (!t.more()) { - break + break; } - c = t.pop() - const y = Utils.unhex(c) + c = t.pop(); + const y = Utils.unhex(c); if (x < 0 || y < 0) { - break + break; } - return x * 16 + y + return x * 16 + y; } case 0x61: - return 0x07 + return 0x07; case 0x66: - return 0x0c + return 0x0c; case 0x6e: - return 0x0a + return 0x0a; case 0x72: - return 0x0d + return 0x0d; case 0x74: - return 0x09 + return 0x09; case 0x76: - return 0x0b + return 0x0b; default: if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) { - return c + return c; } - break + break; } - throw new RE2JSSyntaxException(Parser.ERR_INVALID_ESCAPE, t.from(startPos)) + throw new RE2JSSyntaxException(Parser.ERR_INVALID_ESCAPE, t.from(startPos)); } // parseClassChar parses a character class character and returns it. @@ -501,82 +522,85 @@ class Parser { // Pre: t at class char; Post: t after it. static parseClassChar(t: StringIterator, wholeClassPos: number): number { if (!t.more()) { - throw new RE2JSSyntaxException(Parser.ERR_MISSING_BRACKET, t.from(wholeClassPos)) + throw new RE2JSSyntaxException( + Parser.ERR_MISSING_BRACKET, + t.from(wholeClassPos), + ); } - if (t.lookingAt('\\')) { - return Parser.parseEscape(t) + if (t.lookingAt("\\")) { + return Parser.parseEscape(t); } - return t.pop() + return t.pop(); } static concatRunes(x: number[], y: number[]): number[] { - const r = new Array(x.length + y.length) - for (let i = 0; i < x.length; i++) r[i] = x[i] - for (let i = 0; i < y.length; i++) r[x.length + i] = y[i] - return r + const r = new Array(x.length + y.length); + for (let i = 0; i < x.length; i++) r[i] = x[i]; + for (let i = 0; i < y.length; i++) r[x.length + i] = y[i]; + return r; } - wholeRegexp: string - flags: number - numCap: number - namedGroups: any - stack: any[] - free: any - numRegexp: number - numRunes: number - repeats: number - height: Map | null - size: Map | null + wholeRegexp: string; + flags: number; + numCap: number; + namedGroups: Map; + stack: Regexp[]; + free: any; + numRegexp: number; + numRunes: number; + repeats: number; + height: Map | null; + size: Map | null; constructor(wholeRegexp: string, flags = 0) { - this.wholeRegexp = wholeRegexp + this.wholeRegexp = wholeRegexp; // Flags control the behavior of the parser and record information about // regexp context. - this.flags = flags + this.flags = flags; // number of capturing groups seen - this.numCap = 0 - this.namedGroups = Object.create(null) + this.numCap = 0; + this.namedGroups = new Map(); // Stack of parsed expressions. - this.stack = [] - this.free = null + this.stack = []; + this.free = null; // checks - this.numRegexp = 0 // number of regexps allocated - this.numRunes = 0 // number of runes in char classes - this.repeats = 0 // product of all repetitions seen - this.height = null // regexp height, for height limit check - this.size = null // regexp compiled size, for size limit check + this.numRegexp = 0; // number of regexps allocated + this.numRunes = 0; // number of runes in char classes + this.repeats = 0; // product of all repetitions seen + this.height = null; // regexp height, for height limit check + this.size = null; // regexp compiled size, for size limit check } // Allocate a Regexp, from the free list if possible. newRegexp(op: number): Regexp { - let re = this.free + let re = this.free; if (re !== null && re.subs !== null && re.subs.length > 0) { - this.free = re.subs[0] - re.reinit() - re.op = op + this.free = re.subs[0]; + re.reinit(); + re.op = op; } else { - re = new Regexp(op) - this.numRegexp += 1 + re = new Regexp(op); + this.numRegexp += 1; } - return re + return re; } reuse(re: Regexp): void { if (this.height !== null) { - this.height.delete(re) + this.height.delete(re); } if (re.subs !== null && re.subs.length > 0) { - re.subs[0] = this.free + re.subs[0] = this.free; } - this.free = re + this.free = re; } checkLimits(re: Regexp): void { if (this.numRunes > Parser.MAX_RUNES) { - throw new RE2JSSyntaxException(Parser.ERR_LARGE) + throw new RE2JSSyntaxException(Parser.ERR_LARGE); } - this.checkSize(re) - this.checkHeight(re) + this.checkSize(re); + this.checkHeight(re); } checkSize(re: Regexp): void { @@ -587,157 +611,161 @@ class Parser { // and don't track if the total number of regexp nodes // we've seen times the repeat product is in budget. if (this.repeats === 0) { - this.repeats = 1 + this.repeats = 1; } if (re.op === Regexp.Op.REPEAT) { - let n = re.max + let n = re.max; if (n === -1) { - n = re.min + n = re.min; } if (n <= 0) { - n = 1 + n = 1; } if (n > Parser.MAX_SIZE / this.repeats) { - this.repeats = Parser.MAX_SIZE + this.repeats = Parser.MAX_SIZE; } else { - this.repeats *= n + this.repeats *= n; } } if (this.numRegexp < Parser.MAX_SIZE / this.repeats) { - return + return; } // We need to start tracking size. // Make the map and belatedly populate it // with info about everything we've constructed so far. - this.size = new Map() + this.size = new Map(); for (let reEx of this.stack) { - this.checkSize(reEx) + this.checkSize(reEx); } } if (this.calcSize(re, true) > Parser.MAX_SIZE) { - throw new RE2JSSyntaxException(Parser.ERR_LARGE) + throw new RE2JSSyntaxException(Parser.ERR_LARGE); } } calcSize(re: Regexp, force = false): number { if (!force && this.size!.has(re)) { - return this.size!.get(re)! + return this.size!.get(re)!; } - let size = 0 + let size = 0; switch (re.op) { case Regexp.Op.LITERAL: { - size = re.runes.length - break + size = re.runes.length; + break; } case Regexp.Op.CAPTURE: case Regexp.Op.STAR: { // star can be 1+ or 2+; assume 2 pessimistically - size = 2 + this.calcSize(re.subs[0]) - break + size = 2 + this.calcSize(re.subs[0]); + break; } case Regexp.Op.PLUS: case Regexp.Op.QUEST: { - size = 1 + this.calcSize(re.subs[0]) - break + size = 1 + this.calcSize(re.subs[0]); + break; } case Regexp.Op.CONCAT: { for (let sub of re.subs) { - size = size + this.calcSize(sub) + size = size + this.calcSize(sub); } - break + break; } case Regexp.Op.ALTERNATE: { for (let sub of re.subs) { - size = size + this.calcSize(sub) + size = size + this.calcSize(sub); } if (re.subs.length > 1) { - size = size + re.subs.length - 1 + size = size + re.subs.length - 1; } - break + break; } case Regexp.Op.REPEAT: { - let sub = this.calcSize(re.subs[0]) + let sub = this.calcSize(re.subs[0]); if (re.max === -1) { if (re.min === 0) { - size = 2 + sub // x* + size = 2 + sub; // x* } else { - size = 1 + re.min * sub // xxx+ + size = 1 + re.min * sub; // xxx+ } - break + break; } // x{2,5} = xx(x(x(x)?)?)? - size = re.max * sub + (re.max - re.min) - break + size = re.max * sub + (re.max - re.min); + break; } } - size = Math.max(1, size) - this.size!.set(re, size) - return size + size = Math.max(1, size); + this.size!.set(re, size); + return size; } checkHeight(re: Regexp): void { if (this.numRegexp < Parser.MAX_HEIGHT) { - return + return; } if (this.height === null) { - this.height = new Map() + this.height = new Map(); for (let reEx of this.stack) { - this.checkHeight(reEx) + this.checkHeight(reEx); } } if (this.calcHeight(re, true) > Parser.MAX_HEIGHT) { - throw new RE2JSSyntaxException(Parser.ERR_NESTING_DEPTH) + throw new RE2JSSyntaxException(Parser.ERR_NESTING_DEPTH); } } calcHeight(re: Regexp, force = false): number { if (!force && this.height!.has(re)) { - return this.height!.get(re)! + return this.height!.get(re)!; } - let h = 1 + let h = 1; for (let sub of re.subs) { - const hsub = this.calcHeight(sub) + const hsub = this.calcHeight(sub); if (h < 1 + hsub) { - h = 1 + hsub + h = 1 + hsub; } } - this.height!.set(re, h) - return h + this.height!.set(re, h); + return h; } // Parse stack manipulation. - pop(): Regexp { - return this.stack.pop() + pop(): Regexp | undefined { + return this.stack.pop(); } popToPseudo(): Regexp[] { - const n = this.stack.length - let i = n + const n = this.stack.length; + let i = n; while (i > 0 && !Regexp.isPseudoOp(this.stack[i - 1].op)) { - i-- + i--; } - const r = this.stack.slice(i, n) - this.stack = this.stack.slice(0, i) - return r + const r = this.stack.slice(i, n); + this.stack = this.stack.slice(0, i); + return r; } // push pushes the regexp re onto the parse stack and returns the regexp. // Returns null for a CHAR_CLASS that can be merged with the top-of-stack. push(re: Regexp): Regexp | null { - this.numRunes += re.runes.length - if (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 2 && re.runes[0] === re.runes[1]) { + this.numRunes += re.runes.length; + if ( + re.op === Regexp.Op.CHAR_CLASS && + re.runes.length === 2 && + re.runes[0] === re.runes[1] + ) { if (this.maybeConcat(re.runes[0], this.flags & ~RE2Flags.FOLD_CASE)) { - return null + return null; } - re.op = Regexp.Op.LITERAL - re.runes = [re.runes[0]] - re.flags = this.flags & ~RE2Flags.FOLD_CASE + re.op = Regexp.Op.LITERAL; + re.runes = [re.runes[0]]; + re.flags = this.flags & ~RE2Flags.FOLD_CASE; } else if ( (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 4 && @@ -753,19 +781,19 @@ class Parser { ) { // Case-insensitive rune like [Aa] or [Δδ]. if (this.maybeConcat(re.runes[0], this.flags | RE2Flags.FOLD_CASE)) { - return null + return null; } // Rewrite as (case-insensitive) literal. - re.op = Regexp.Op.LITERAL - re.runes = [re.runes[0]] - re.flags = this.flags | RE2Flags.FOLD_CASE + re.op = Regexp.Op.LITERAL; + re.runes = [re.runes[0]]; + re.flags = this.flags | RE2Flags.FOLD_CASE; } else { // Incremental concatenation. - this.maybeConcat(-1, 0) + this.maybeConcat(-1, 0); } - this.stack.push(re) - this.checkLimits(re) - return re + this.stack.push(re); + this.checkLimits(re); + return re; } // maybeConcat implements incremental concatenation @@ -778,55 +806,55 @@ class Parser { // to push r with the given flags. // maybeConcat reports whether r was pushed. maybeConcat(r: number, flags: number): boolean { - const n = this.stack.length + const n = this.stack.length; if (n < 2) { - return false + return false; } - const re1 = this.stack[n - 1] - const re2 = this.stack[n - 2] + const re1 = this.stack[n - 1]; + const re2 = this.stack[n - 2]; if ( re1.op !== Regexp.Op.LITERAL || re2.op !== Regexp.Op.LITERAL || (re1.flags & RE2Flags.FOLD_CASE) !== (re2.flags & RE2Flags.FOLD_CASE) ) { - return false + return false; } // Push re1 into re2. - re2.runes = Parser.concatRunes(re2.runes, re1.runes) + re2.runes = Parser.concatRunes(re2.runes, re1.runes); // Reuse re1 if possible. if (r >= 0) { - re1.runes = [r] - re1.flags = flags - return true + re1.runes = [r]; + re1.flags = flags; + return true; } - this.pop() - this.reuse(re1) - return false // did not push r + this.pop(); + this.reuse(re1); + return false; // did not push r } // newLiteral returns a new LITERAL Regexp with the given flags newLiteral(r: number, flags: number): Regexp { - const re = this.newRegexp(Regexp.Op.LITERAL) - re.flags = flags + const re = this.newRegexp(Regexp.Op.LITERAL); + re.flags = flags; if ((flags & RE2Flags.FOLD_CASE) !== 0) { - r = Parser.minFoldRune(r) + r = Parser.minFoldRune(r); } - re.runes = [r] - return re + re.runes = [r]; + return re; } // literal pushes a literal regexp for the rune r on the stack // and returns that regexp. literal(r: number): void { - this.push(this.newLiteral(r, this.flags)) + this.push(this.newLiteral(r, this.flags)); } // op pushes a regexp with the given op onto the stack // and returns that regexp. op(op: number): Regexp | null { - const re = this.newRegexp(op) - re.flags = this.flags - return this.push(re) + const re = this.newRegexp(op); + re.flags = this.flags; + return this.push(re); } // repeat replaces the top stack element with itself repeated according to @@ -840,38 +868,54 @@ class Parser { max: number, beforePos: number, t: StringIterator, - lastRepeatPos: number + lastRepeatPos: number, ): void { - let flags = this.flags - if (t.more() && t.lookingAt('?')) { - t.skip(1) - flags ^= RE2Flags.NON_GREEDY + let flags = this.flags; + if (t.more() && t.lookingAt("?")) { + t.skip(1); + flags ^= RE2Flags.NON_GREEDY; } if (lastRepeatPos !== -1) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_OP, t.from(lastRepeatPos)) + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_REPEAT_OP, + t.from(lastRepeatPos), + ); } - const n = this.stack.length + const n = this.stack.length; if (n === 0) { - throw new RE2JSSyntaxException(Parser.ERR_MISSING_REPEAT_ARGUMENT, t.from(beforePos)) + throw new RE2JSSyntaxException( + Parser.ERR_MISSING_REPEAT_ARGUMENT, + t.from(beforePos), + ); } - const sub = this.stack[n - 1] + const sub = this.stack[n - 1]; if (Regexp.isPseudoOp(sub.op)) { - throw new RE2JSSyntaxException(Parser.ERR_MISSING_REPEAT_ARGUMENT, t.from(beforePos)) + throw new RE2JSSyntaxException( + Parser.ERR_MISSING_REPEAT_ARGUMENT, + t.from(beforePos), + ); } - const re = this.newRegexp(op) - re.min = min - re.max = max - re.flags = flags - re.subs = [sub] - this.stack[n - 1] = re + const re = this.newRegexp(op); + re.min = min; + re.max = max; + re.flags = flags; + re.subs = [sub]; + this.stack[n - 1] = re; - this.checkLimits(re) + this.checkLimits(re); - if (op === Regexp.Op.REPEAT && (min >= 2 || max >= 2) && !this.repeatIsValid(re, 1000)) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_SIZE, t.from(beforePos)) + if ( + op === Regexp.Op.REPEAT && + (min >= 2 || max >= 2) && + !this.repeatIsValid(re, 1000) + ) { + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_REPEAT_SIZE, + t.from(beforePos), + ); } } @@ -886,39 +930,39 @@ class Parser { // triggering a parse error, so each subtree can only be rewalked 9 times. repeatIsValid(re: Regexp, n: number): boolean { if (re.op === Regexp.Op.REPEAT) { - let m = re.max + let m = re.max; if (m === 0) { - return true + return true; } if (m < 0) { - m = re.min + m = re.min; } if (m > n) { - return false + return false; } if (m > 0) { - n = Math.trunc(n / m) + n = Math.trunc(n / m); } } for (let sub of re.subs) { if (!this.repeatIsValid(sub, n)) { - return false + return false; } } - return true + return true; } // concat replaces the top of the stack (above the topmost '|' or '(') with // its concatenation. concat(): Regexp | null { - this.maybeConcat(-1, 0) - const subs = this.popToPseudo() + this.maybeConcat(-1, 0); + const subs = this.popToPseudo(); if (subs.length === 0) { - return this.push(this.newRegexp(Regexp.Op.EMPTY_MATCH)) + return this.push(this.newRegexp(Regexp.Op.EMPTY_MATCH)); } - return this.push(this.collapse(subs, Regexp.Op.CONCAT)) + return this.push(this.collapse(subs, Regexp.Op.CONCAT)); } // alternate replaces the top of the stack (above the topmost '(') with its @@ -926,27 +970,31 @@ class Parser { alternate(): Regexp | null { // Scan down to find pseudo-operator (. // There are no | above (. - const subs = this.popToPseudo() + const subs = this.popToPseudo(); // Make sure top class is clean. // All the others already are (see swapVerticalBar). if (subs.length > 0) { - this.cleanAlt(subs[subs.length - 1]) + this.cleanAlt(subs[subs.length - 1]); } // Empty alternate is special case // (shouldn't happen but easy to handle). if (subs.length === 0) { - return this.push(this.newRegexp(Regexp.Op.NO_MATCH)) + return this.push(this.newRegexp(Regexp.Op.NO_MATCH)); } - return this.push(this.collapse(subs, Regexp.Op.ALTERNATE)) + return this.push(this.collapse(subs, Regexp.Op.ALTERNATE)); } // cleanAlt cleans re for eventual inclusion in an alternation. cleanAlt(re: Regexp): void { if (re.op === Regexp.Op.CHAR_CLASS) { - re.runes = new CharClass(re.runes).cleanClass().toArray() - if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) { - re.runes = [] - re.op = Regexp.Op.ANY_CHAR + re.runes = new CharClass(re.runes).cleanClass().toArray(); + if ( + re.runes.length === 2 && + re.runes[0] === 0 && + re.runes[1] === Unicode.MAX_RUNE + ) { + re.runes = []; + re.op = Regexp.Op.ANY_CHAR; } else if ( re.runes.length === 4 && re.runes[0] === 0 && @@ -954,8 +1002,8 @@ class Parser { re.runes[2] === 0x0a + 1 && re.runes[3] === Unicode.MAX_RUNE ) { - re.runes = [] - re.op = Regexp.Op.ANY_CHAR_NOT_NL + re.runes = []; + re.op = Regexp.Op.ANY_CHAR_NOT_NL; } } } @@ -966,226 +1014,239 @@ class Parser { // alternate of an alternate. collapse(subs: Regexp[], op: number): Regexp { if (subs.length === 1) { - return subs[0] + return subs[0]; } // Concatenate subs iff op is same. // Compute length in first pass. - let len = 0 + let len = 0; for (let sub of subs) { - len += sub.op === op ? sub.subs.length : 1 + len += sub.op === op ? sub.subs.length : 1; } - let newsubs = new Array(len).fill(null) - let i = 0 + let newsubs = new Array(len).fill(null); + let i = 0; for (let sub of subs) { if (sub.op === op) { for (let j = 0; j < sub.subs.length; j++) { - newsubs[i++] = sub.subs[j] + newsubs[i++] = sub.subs[j]; } - this.reuse(sub) + this.reuse(sub); } else { - newsubs[i++] = sub + newsubs[i++] = sub; } } - let re = this.newRegexp(op) - re.subs = newsubs + let re = this.newRegexp(op); + re.subs = newsubs; if (op === Regexp.Op.ALTERNATE) { if (re.subs.length === 1) { - const old = re - re = re.subs[0] - this.reuse(old) + const old = re; + re = re.subs[0]; + this.reuse(old); } } - return re + return re; } parseInternal(): Regexp { if ((this.flags & RE2Flags.LITERAL) !== 0) { // Trivial parser for literal string. - return Parser.literalRegexp(this.wholeRegexp, this.flags) + return Parser.literalRegexp(this.wholeRegexp, this.flags); } // Otherwise, must do real work. - let lastRepeatPos = -1 - let min = -1 - let max = -1 - const t = new StringIterator(this.wholeRegexp) + let lastRepeatPos = -1; + let min = -1; + let max = -1; + const t = new StringIterator(this.wholeRegexp); while (t.more()) { { - let repeatPos = -1 + let repeatPos = -1; bigswitch: switch (t.peek()) { case 0x28: - if (t.lookingAt('(?')) { + if (t.lookingAt("(?")) { // Flag changes and non-capturing groups. - this.parsePerlFlags(t) - break + this.parsePerlFlags(t); + break; } - this.op(Regexp.Op.LEFT_PAREN)!.cap = ++this.numCap - t.skip(1) // '(' - break + this.op(Regexp.Op.LEFT_PAREN)!.cap = ++this.numCap; + t.skip(1); // '(' + break; case 0x7c: - this.parseVerticalBar() // '|' - t.skip(1) // '|' - break + this.parseVerticalBar(); // '|' + t.skip(1); // '|' + break; case 0x29: - this.parseRightParen() - t.skip(1) // ')' - break + this.parseRightParen(); + t.skip(1); // ')' + break; case 0x5e: if ((this.flags & RE2Flags.ONE_LINE) !== 0) { - this.op(Regexp.Op.BEGIN_TEXT) + this.op(Regexp.Op.BEGIN_TEXT); } else { - this.op(Regexp.Op.BEGIN_LINE) + this.op(Regexp.Op.BEGIN_LINE); } - t.skip(1) // '^' - break + t.skip(1); // '^' + break; case 0x24: if ((this.flags & RE2Flags.ONE_LINE) !== 0) { - this.op(Regexp.Op.END_TEXT)!.flags |= RE2Flags.WAS_DOLLAR + this.op(Regexp.Op.END_TEXT)!.flags |= RE2Flags.WAS_DOLLAR; } else { - this.op(Regexp.Op.END_LINE) + this.op(Regexp.Op.END_LINE); } - t.skip(1) // '$' - break + t.skip(1); // '$' + break; case 0x2e: if ((this.flags & RE2Flags.DOT_NL) !== 0) { - this.op(Regexp.Op.ANY_CHAR) + this.op(Regexp.Op.ANY_CHAR); } else { - this.op(Regexp.Op.ANY_CHAR_NOT_NL) + this.op(Regexp.Op.ANY_CHAR_NOT_NL); } - t.skip(1) // '.' - break + t.skip(1); // '.' + break; case 0x5b: - this.parseClass(t) - break + this.parseClass(t); + break; case 0x2a: case 0x2b: case 0x3f: { - repeatPos = t.pos() - let op: number | null = null + repeatPos = t.pos(); + let op: number | null = null; switch (t.pop()) { case 0x2a: - op = Regexp.Op.STAR - break + op = Regexp.Op.STAR; + break; case 0x2b: - op = Regexp.Op.PLUS - break + op = Regexp.Op.PLUS; + break; case 0x3f: - op = Regexp.Op.QUEST - break + op = Regexp.Op.QUEST; + break; } - this.repeat(op!, min, max, repeatPos, t, lastRepeatPos) + this.repeat(op!, min, max, repeatPos, t, lastRepeatPos); // (min and max are now dead.) - break + break; } case 0x7b: { - repeatPos = t.pos() - const minMax = Parser.parseRepeat(t) + repeatPos = t.pos(); + const minMax = Parser.parseRepeat(t); if (minMax < 0) { // If the repeat cannot be parsed, { is a literal. - t.rewindTo(repeatPos) - this.literal(t.pop()) // '{' - break + t.rewindTo(repeatPos); + this.literal(t.pop()); // '{' + break; } - min = minMax >> 16 - max = ((minMax & Unicode.MAX_BMP) << 16) >> 16 - this.repeat(Regexp.Op.REPEAT, min, max, repeatPos, t, lastRepeatPos) - break + min = minMax >> 16; + max = ((minMax & Unicode.MAX_BMP) << 16) >> 16; + this.repeat( + Regexp.Op.REPEAT, + min, + max, + repeatPos, + t, + lastRepeatPos, + ); + break; } case 0x5c: { - const savedPos = t.pos() - t.skip(1) // '\\' + const savedPos = t.pos(); + t.skip(1); // '\\' if (t.more()) { - const c = t.pop() + const c = t.pop(); switch (c) { case 0x41: - this.op(Regexp.Op.BEGIN_TEXT) - break bigswitch + this.op(Regexp.Op.BEGIN_TEXT); + break bigswitch; case 0x62: - this.op(Regexp.Op.WORD_BOUNDARY) - break bigswitch + this.op(Regexp.Op.WORD_BOUNDARY); + break bigswitch; case 0x42: - this.op(Regexp.Op.NO_WORD_BOUNDARY) - break bigswitch + this.op(Regexp.Op.NO_WORD_BOUNDARY); + break bigswitch; case 0x43: // any byte; not supported - throw new RE2JSSyntaxException(Parser.ERR_INVALID_ESCAPE, '\\C') + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_ESCAPE, + "\\C", + ); case 0x51: { // \Q ... \E: the ... is always literals - let lit = t.rest() - const i = lit.indexOf('\\E') + let lit = t.rest(); + const i = lit.indexOf("\\E"); if (i >= 0) { - lit = lit.substring(0, i) - t.skipString(lit) - t.skipString('\\E') + lit = lit.substring(0, i); + t.skipString(lit); + t.skipString("\\E"); } else { - t.skipString(lit) + t.skipString(lit); } - let j = 0 + let j = 0; while (j < lit.length) { - const codepoint = lit.codePointAt(j)! - this.literal(codepoint) - j += Utils.charCount(codepoint) + const codepoint = lit.codePointAt(j)!; + this.literal(codepoint); + j += Utils.charCount(codepoint); } - break bigswitch + break bigswitch; } case 0x7a: - this.op(Regexp.Op.END_TEXT) - break bigswitch + this.op(Regexp.Op.END_TEXT); + break bigswitch; default: - t.rewindTo(savedPos) - break + t.rewindTo(savedPos); + break; } } else { - t.rewindTo(savedPos) + t.rewindTo(savedPos); } - const re = this.newRegexp(Regexp.Op.CHAR_CLASS) - re.flags = this.flags + const re = this.newRegexp(Regexp.Op.CHAR_CLASS); + re.flags = this.flags; // Look for Unicode character group like \p{Han} - if (t.lookingAt('\\p') || t.lookingAt('\\P')) { - const cc = new CharClass() + if (t.lookingAt("\\p") || t.lookingAt("\\P")) { + const cc = new CharClass(); if (this.parseUnicodeClass(t, cc)) { - re.runes = cc.toArray() - this.push(re) - break bigswitch + re.runes = cc.toArray(); + this.push(re); + break bigswitch; } } // Perl character class escape. - const cc = new CharClass() + const cc = new CharClass(); if (this.parsePerlClassEscape(t, cc)) { - re.runes = cc.toArray() - this.push(re) - break bigswitch + re.runes = cc.toArray(); + this.push(re); + break bigswitch; } - t.rewindTo(savedPos) - this.reuse(re) + t.rewindTo(savedPos); + this.reuse(re); // Ordinary single-character escape. - this.literal(Parser.parseEscape(t)) - break + this.literal(Parser.parseEscape(t)); + break; } default: - this.literal(t.pop()) - break + this.literal(t.pop()); + break; } - lastRepeatPos = repeatPos + lastRepeatPos = repeatPos; } } - this.concat() + this.concat(); if (this.swapVerticalBar()) { - this.pop() // pop vertical bar + this.pop(); // pop vertical bar } - this.alternate() - const n = this.stack.length + this.alternate(); + const n = this.stack.length; if (n !== 1) { - throw new RE2JSSyntaxException(Parser.ERR_MISSING_PAREN, this.wholeRegexp) + throw new RE2JSSyntaxException( + Parser.ERR_MISSING_PAREN, + this.wholeRegexp, + ); } - this.stack[0].namedGroups = this.namedGroups - return this.stack[0] + this.stack[0].namedGroups = this.namedGroups; + return this.stack[0]; } // parsePerlFlags parses a Perl flag setting or non-capturing group or both, @@ -1193,7 +1254,7 @@ class Parser { // Pre: t at "(?". Post: t after ")". // Sets numCap. parsePerlFlags(t: StringIterator): void { - const startPos = t.pos() + const startPos = t.pos(); // Check for named captures, first introduced in Python's regexp library. // As usual, there are three slightly different syntaxes: // @@ -1209,102 +1270,111 @@ class Parser { // In both the open source world (via Code Search) and the // Google source tree, (?Pexpr) and (?expr) are the // dominant forms of named captures and both are supported. - if (t.lookingAt('(?P<') || t.lookingAt('(?<')) { + if (t.lookingAt("(?P<") || t.lookingAt("(?<")) { // Pull out name. - const s = t.rest() - const begin = s.charAt(2) === 'P' ? 4 : 3 - const end = s.indexOf('>') + const s = t.rest(); + const begin = s.charAt(2) === "P" ? 4 : 3; + const end = s.indexOf(">"); if (end < 0) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s) + throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s); } - const name = s.substring(begin, end) // "name" - t.skipString(name) - t.skip(begin + 1) // "(?P<>" or "(?<>" + const name = s.substring(begin, end); // "name" + t.skipString(name); + t.skip(begin + 1); // "(?P<>" or "(?<>" if (!Parser.isValidCaptureName(name)) { // "(?P" - throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s.substring(0, end + 1)) // "(?P" or "(?" + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_NAMED_CAPTURE, + s.substring(0, end + 1), + ); // "(?P" or "(?" } // Like ordinary capture, but named. - const re = this.op(Regexp.Op.LEFT_PAREN)! - re.cap = ++this.numCap - if (this.namedGroups[name]) { - throw new RE2JSSyntaxException(Parser.ERR_DUPLICATE_NAMED_CAPTURE, name) + const re = this.op(Regexp.Op.LEFT_PAREN)!; + re.cap = ++this.numCap; + if (this.namedGroups.get(name)) { + throw new RE2JSSyntaxException( + Parser.ERR_DUPLICATE_NAMED_CAPTURE, + name, + ); } - this.namedGroups[name] = this.numCap - re.name = name - return + this.namedGroups.set(name, this.numCap); + re.name = name; + return; } // Non-capturing group. Might also twiddle Perl flags. - t.skip(2) // "(?" + t.skip(2); // "(?" - let flags = this.flags - let sign = +1 - let sawFlag = false + let flags = this.flags; + let sign = +1; + let sawFlag = false; loop: while (t.more()) { { - const c = t.pop() + const c = t.pop(); switch (c) { case 0x69: - flags |= RE2Flags.FOLD_CASE - sawFlag = true - break + flags |= RE2Flags.FOLD_CASE; + sawFlag = true; + break; case 0x6d: - flags &= ~RE2Flags.ONE_LINE - sawFlag = true - break + flags &= ~RE2Flags.ONE_LINE; + sawFlag = true; + break; case 0x73: - flags |= RE2Flags.DOT_NL - sawFlag = true - break + flags |= RE2Flags.DOT_NL; + sawFlag = true; + break; case 0x55: - flags |= RE2Flags.NON_GREEDY - sawFlag = true - break + flags |= RE2Flags.NON_GREEDY; + sawFlag = true; + break; // Switch to negation. case 0x2d: if (sign < 0) { - break loop + break loop; } - sign = -1 + sign = -1; // Invert flags so that | above turn into &~ and vice versa. // We'll invert flags again before using it below. - flags = ~flags - sawFlag = false - break + flags = ~flags; + sawFlag = false; + break; // End of flags, starting group or not. case 0x3a: case 0x29: if (sign < 0) { if (!sawFlag) { - break loop + break loop; } - flags = ~flags + flags = ~flags; } if (c === 0x3a) { // Open new group - this.op(Regexp.Op.LEFT_PAREN) + this.op(Regexp.Op.LEFT_PAREN); } - this.flags = flags - return + this.flags = flags; + return; default: // Flags. - break loop + break loop; } } } - throw new RE2JSSyntaxException(Parser.ERR_INVALID_PERL_OP, t.from(startPos)) + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_PERL_OP, + t.from(startPos), + ); } // parseVerticalBar handles a | in the input. parseVerticalBar(): void { - this.concat() + this.concat(); // The concatenation we just parsed is on top of the stack. // If it sits above an opVerticalBar, swap it below // (things below an opVerticalBar become an alternation). // Otherwise, push a new vertical bar. if (!this.swapVerticalBar()) { - this.op(Regexp.Op.VERTICAL_BAR) + this.op(Regexp.Op.VERTICAL_BAR); } } @@ -1312,7 +1382,7 @@ class Parser { // swapVerticalBar swaps the two and returns true. // Otherwise it returns false. swapVerticalBar(): boolean { - const n = this.stack.length + const n = this.stack.length; // If above and below vertical bar are literal or char class, // can merge into a single char class. if ( @@ -1321,63 +1391,75 @@ class Parser { Parser.isCharClass(this.stack[n - 1]) && Parser.isCharClass(this.stack[n - 3]) ) { - let re1 = this.stack[n - 1] - let re3 = this.stack[n - 3] + let re1 = this.stack[n - 1]; + let re3 = this.stack[n - 3]; // Make re3 the more complex of the two. if (re1.op > re3.op) { - const tmp = re3 - re3 = re1 - re1 = tmp - this.stack[n - 3] = re3 + const tmp = re3; + re3 = re1; + re1 = tmp; + this.stack[n - 3] = re3; } - Parser.mergeCharClass(re3, re1) - this.reuse(re1) - this.pop() - return true + Parser.mergeCharClass(re3, re1); + this.reuse(re1); + this.pop(); + return true; } if (n >= 2) { - const re1 = this.stack[n - 1] - const re2 = this.stack[n - 2] + const re1 = this.stack[n - 1]; + const re2 = this.stack[n - 2]; if (re2.op === Regexp.Op.VERTICAL_BAR) { if (n >= 3) { // Now out of reach. // Clean opportunistically. - this.cleanAlt(this.stack[n - 3]) + this.cleanAlt(this.stack[n - 3]); } - this.stack[n - 2] = re1 - this.stack[n - 1] = re2 - return true + this.stack[n - 2] = re1; + this.stack[n - 1] = re2; + return true; } } - return false + return false; } // parseRightParen handles a ')' in the input. parseRightParen(): void { - this.concat() + this.concat(); if (this.swapVerticalBar()) { - this.pop() // pop vertical bar + this.pop(); // pop vertical bar } - this.alternate() - const n = this.stack.length + this.alternate(); + const n = this.stack.length; if (n < 2) { - throw new RE2JSSyntaxException(Parser.ERR_UNEXPECTED_PAREN, this.wholeRegexp) - } - - const re1 = this.pop() - const re2 = this.pop() - if (re2.op !== Regexp.Op.LEFT_PAREN) { - throw new RE2JSSyntaxException(Parser.ERR_UNEXPECTED_PAREN, this.wholeRegexp) + throw new RE2JSSyntaxException( + Parser.ERR_UNEXPECTED_PAREN, + this.wholeRegexp, + ); + } + + const re1 = this.pop(); + if (re1 === undefined) { + throw new RE2JSSyntaxException( + Parser.ERR_BAD_EXPRESSION, + this.wholeRegexp, + ); + } + const re2 = this.pop(); + if (re2 === undefined || re2.op !== Regexp.Op.LEFT_PAREN) { + throw new RE2JSSyntaxException( + Parser.ERR_UNEXPECTED_PAREN, + this.wholeRegexp, + ); } // Restore flags at time of paren. - this.flags = re2.flags + this.flags = re2.flags; if (re2.cap === 0) { // Just for grouping. - this.push(re1) + this.push(re1); } else { - re2.op = Regexp.Op.CAPTURE - re2.subs = [re1] - this.push(re2) + re2.op = Regexp.Op.CAPTURE; + re2.subs = [re1]; + this.push(re2); } } @@ -1386,19 +1468,19 @@ class Parser { // to cc and returns true. The iterator is advanced past the escape // on success, undefined on failure, in which case false is returned. parsePerlClassEscape(t: StringIterator, cc: CharClass): boolean { - const beforePos = t.pos() + const beforePos = t.pos(); if (!t.more() || t.pop() !== 0x5c || !t.more()) { - return false + return false; } - t.pop() // e.g. advance past 'd' in "\\d" - const p = t.from(beforePos) - const perlGroups = getPerlGroups() - const g = perlGroups.has(p) ? perlGroups.get(p) : null + t.pop(); // e.g. advance past 'd' in "\\d" + const p = t.from(beforePos); + const perlGroups = getPerlGroups(); + const g = perlGroups.has(p) ? perlGroups.get(p) : null; if (g === null) { - return false + return false; } - cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0) - return true + cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0); + return true; } // parseNamedClass parses a leading POSIX named character class like @@ -1409,21 +1491,21 @@ class Parser { // On misparse, returns false; t.pos() is undefined. parseNamedClass(t: StringIterator, cc: CharClass): boolean { // (Go precondition check deleted.) - const cls = t.rest() - const i = cls.indexOf(':]') + const cls = t.rest(); + const i = cls.indexOf(":]"); if (i < 0) { - return false + return false; } - const name = cls.substring(0, i + 2) // "[:alnum:]" - t.skipString(name) - const posixGroups = getPosixGroups() - const g = posixGroups.has(name) ? posixGroups.get(name) : null + const name = cls.substring(0, i + 2); // "[:alnum:]" + t.skipString(name); + const posixGroups = getPosixGroups(); + const g = posixGroups.has(name) ? posixGroups.get(name) : null; if (g === null) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, name) + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, name); } - cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0) - return true + cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0); + return true; } // parseUnicodeClass() parses a leading Unicode character class like \p{Han} @@ -1434,74 +1516,81 @@ class Parser { // flag is not enabled; |t.pos()| is not advanced in this case. // Indicates error by throwing RE2JSSyntaxException. parseUnicodeClass(t: StringIterator, cc: CharClass): boolean { - const startPos = t.pos() + const startPos = t.pos(); if ( (this.flags & RE2Flags.UNICODE_GROUPS) === 0 || - (!t.lookingAt('\\p') && !t.lookingAt('\\P')) + (!t.lookingAt("\\p") && !t.lookingAt("\\P")) ) { - return false + return false; } - t.skip(1) // '\\' + t.skip(1); // '\\' // Committed to parse or throw exception. - let sign = +1 - let c = t.pop() // 'p' or 'P' + let sign = +1; + let c = t.pop(); // 'p' or 'P' if (c === 0x50) { - sign = -1 + sign = -1; } if (!t.more()) { - t.rewindTo(startPos) - throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.rest()) + t.rewindTo(startPos); + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.rest()); } - c = t.pop() - let name + c = t.pop(); + let name; if (c !== 0x7b) { // Single-letter name. - name = Utils.runeToString(c) + name = Utils.runeToString(c); } else { // Name is in braces. - const rest = t.rest() - const end = rest.indexOf('}') + const rest = t.rest(); + const end = rest.indexOf("}"); if (end < 0) { - t.rewindTo(startPos) - throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.rest()) + t.rewindTo(startPos); + throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.rest()); } - name = rest.substring(0, end) // e.g. "Han" - t.skipString(name) - t.skip(1) + name = rest.substring(0, end); // e.g. "Han" + t.skipString(name); + t.skip(1); // Don't use skip(end) because it assumes UTF-16 coding, and // StringIterator doesn't guarantee that. } // Group can have leading negation too. // \p{^Han} == \P{Han}, \P{^Han} == \p{Han}. if (!(name.length === 0) && name.codePointAt(0) === 0x5e) { - sign = 0 - sign // -sign - name = name.substring(1) + sign = 0 - sign; // -sign + name = name.substring(1); } - const pair = Parser.unicodeTable(name) + const pair = Parser.unicodeTable(name); if (pair === null) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.from(startPos)) + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_CHAR_RANGE, + t.from(startPos), + ); } if (pair.sign < 0) { - sign = 0 - sign + sign = 0 - sign; } - const tab = pair.tab - const fold = pair.fold // fold-equivalent table + const tab = pair.tab; + const fold = pair.fold; // fold-equivalent table // Variation of CharClass.appendGroup() for tables. if ((this.flags & RE2Flags.FOLD_CASE) === 0 || fold === null) { - cc.appendTableWithSign(tab, sign) + cc.appendTableWithSign(tab, sign); } else { // Merge and clean tab and fold in a temporary buffer. // This is necessary for the negative case and just tidy // for the positive case. - const tmp = new CharClass().appendTable(tab).appendTable(fold).cleanClass().toArray() - cc.appendClassWithSign(tmp, sign) - } - return true + const tmp = new CharClass() + .appendTable(tab) + .appendTable(fold) + .cleanClass() + .toArray(); + cc.appendClassWithSign(tmp, sign); + } + return true; } // parseClass parses a character class and pushes it onto the parse stack. @@ -1510,76 +1599,79 @@ class Parser { // Pre: at '['; Post: after ']'. // Mutates stack. Advances iterator. May throw. parseClass(t: StringIterator): void { - const startPos = t.pos() - t.skip(1) // '[' - const re = this.newRegexp(Regexp.Op.CHAR_CLASS) - re.flags = this.flags - const cc = new CharClass() - let sign = +1 - - if (t.more() && t.lookingAt('^')) { - sign = -1 - t.skip(1) // '^' + const startPos = t.pos(); + t.skip(1); // '[' + const re = this.newRegexp(Regexp.Op.CHAR_CLASS); + re.flags = this.flags; + const cc = new CharClass(); + let sign = +1; + + if (t.more() && t.lookingAt("^")) { + sign = -1; + t.skip(1); // '^' // If character class does not match \n, add it here, // so that negation later will do the right thing. if ((this.flags & RE2Flags.CLASS_NL) === 0) { - cc.appendRange(0x0a, 0x0a) + cc.appendRange(0x0a, 0x0a); } } - let first = true // ']' and '-' are okay as first char in class + let first = true; // ']' and '-' are okay as first char in class while (!t.more() || t.peek() !== 0x5d || first) { - first = false - const beforePos = t.pos() + first = false; + const beforePos = t.pos(); // Look for POSIX [:alnum:] etc. - if (t.lookingAt('[:')) { + if (t.lookingAt("[:")) { if (this.parseNamedClass(t, cc)) { - continue + continue; } - t.rewindTo(beforePos) + t.rewindTo(beforePos); } // Look for Unicode character group like \p{Han}. if (this.parseUnicodeClass(t, cc)) { - continue + continue; } // Look for Perl character class symbols (extension). if (this.parsePerlClassEscape(t, cc)) { - continue + continue; } - t.rewindTo(beforePos) + t.rewindTo(beforePos); // Single character or simple range. - const lo = Parser.parseClassChar(t, startPos) - let hi = lo - if (t.more() && t.lookingAt('-')) { - t.skip(1) - if (t.more() && t.lookingAt(']')) { + const lo = Parser.parseClassChar(t, startPos); + let hi = lo; + if (t.more() && t.lookingAt("-")) { + t.skip(1); + if (t.more() && t.lookingAt("]")) { // [a-] means (a|-) so check for final ]. - t.skip(-1) + t.skip(-1); } else { - hi = Parser.parseClassChar(t, startPos) + hi = Parser.parseClassChar(t, startPos); if (hi < lo) { - throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.from(beforePos)) + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_CHAR_RANGE, + t.from(beforePos), + ); } } } if ((this.flags & RE2Flags.FOLD_CASE) === 0) { - cc.appendRange(lo, hi) + cc.appendRange(lo, hi); } else { - cc.appendFoldedRange(lo, hi) + cc.appendFoldedRange(lo, hi); } } - t.skip(1) // ']' + t.skip(1); // ']' - cc.cleanClass() + cc.cleanClass(); if (sign < 0) { - cc.negateClass() + cc.negateClass(); } - re.runes = cc.toArray() - this.push(re) + re.runes = cc.toArray(); + this.push(re); } } -export { Parser } +export { Parser }; diff --git a/packages/re2/src/Prefilter.ts b/packages/re2/src/Prefilter.ts index 085c8b7..f5b794f 100644 --- a/packages/re2/src/Prefilter.ts +++ b/packages/re2/src/Prefilter.ts @@ -1,50 +1,51 @@ -import { Regexp } from './Regexp.js' +import { Regexp } from "./Regexp.js"; -import { RE2Flags } from './RE2Flags.js' +import { RE2Flags } from "./RE2Flags.js"; +import type { MachineUTF16Input } from "./MachineInput.js"; class Prefilter { - type: number - subs: any[] - str: string + type: number; + subs: any[]; + str: string; - static Type = { NONE: 0, EXACT: 1, AND: 2, OR: 3 } + static Type = { NONE: 0, EXACT: 1, AND: 2, OR: 3 }; constructor(type: number) { - this.type = type - this.subs = [] - this.str = '' + this.type = type; + this.subs = []; + this.str = ""; } - eval(input: any, pos: number): boolean { + eval(input: MachineUTF16Input, pos: number): boolean { switch (this.type) { case Prefilter.Type.NONE: - return true + return true; case Prefilter.Type.EXACT: - return input.hasString(this, pos) + return input.hasString(this, pos); case Prefilter.Type.AND: for (let i = 0; i < this.subs.length; i++) { - if (!this.subs[i].eval(input, pos)) return false + if (!this.subs[i].eval(input, pos)) return false; } - return true + return true; case Prefilter.Type.OR: for (let i = 0; i < this.subs.length; i++) { - if (this.subs[i].eval(input, pos)) return true + if (this.subs[i].eval(input, pos)) return true; } - return false + return false; default: - return true + return true; } } } class PrefilterTree { static build(re: Regexp): Prefilter { - const pf = PrefilterTree.fromRegexp(re) - return PrefilterTree.simplify(pf) + const pf = PrefilterTree.fromRegexp(re); + return PrefilterTree.simplify(pf); } static fromRegexp(re: Regexp): Prefilter { - if (!re) return new Prefilter(Prefilter.Type.NONE) + if (!re) return new Prefilter(Prefilter.Type.NONE); switch (re.op) { case Regexp.Op.NO_MATCH: @@ -58,116 +59,116 @@ class PrefilterTree { case Regexp.Op.CHAR_CLASS: case Regexp.Op.ANY_CHAR_NOT_NL: case Regexp.Op.ANY_CHAR: { - return new Prefilter(Prefilter.Type.NONE) + return new Prefilter(Prefilter.Type.NONE); } case Regexp.Op.LITERAL: { if (re.runes.length === 0 || (re.flags & RE2Flags.FOLD_CASE) !== 0) { // Skip case-folded literals for simplicity - return new Prefilter(Prefilter.Type.NONE) + return new Prefilter(Prefilter.Type.NONE); } - const pf = new Prefilter(Prefilter.Type.EXACT) - let str = '' + const pf = new Prefilter(Prefilter.Type.EXACT); + let str = ""; for (let i = 0; i < re.runes.length; i++) { - str += String.fromCodePoint(re.runes[i]) + str += String.fromCodePoint(re.runes[i]); } - pf.str = str - return pf + pf.str = str; + return pf; } case Regexp.Op.CAPTURE: case Regexp.Op.PLUS: { - return PrefilterTree.fromRegexp(re.subs[0]) + return PrefilterTree.fromRegexp(re.subs[0]); } case Regexp.Op.REPEAT: { if (re.min >= 1) { - return PrefilterTree.fromRegexp(re.subs[0]) + return PrefilterTree.fromRegexp(re.subs[0]); } - return new Prefilter(Prefilter.Type.NONE) + return new Prefilter(Prefilter.Type.NONE); } case Regexp.Op.CONCAT: { - const pf = new Prefilter(Prefilter.Type.AND) + const pf = new Prefilter(Prefilter.Type.AND); for (const sub of re.subs) { - pf.subs.push(PrefilterTree.fromRegexp(sub)) + pf.subs.push(PrefilterTree.fromRegexp(sub)); } - return pf + return pf; } case Regexp.Op.ALTERNATE: { - const pf = new Prefilter(Prefilter.Type.OR) + const pf = new Prefilter(Prefilter.Type.OR); for (const sub of re.subs) { - pf.subs.push(PrefilterTree.fromRegexp(sub)) + pf.subs.push(PrefilterTree.fromRegexp(sub)); } - return pf + return pf; } default: - return new Prefilter(Prefilter.Type.NONE) + return new Prefilter(Prefilter.Type.NONE); } } static simplify(pf: Prefilter): Prefilter { if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) { - return pf + return pf; } if (pf.type === Prefilter.Type.AND) { - const newSubs = [] + const newSubs = []; for (const sub of pf.subs) { - const s = PrefilterTree.simplify(sub) + const s = PrefilterTree.simplify(sub); if (s.type !== Prefilter.Type.NONE) { if (s.type === Prefilter.Type.AND) { - newSubs.push(...s.subs) + newSubs.push(...s.subs); } else { - newSubs.push(s) + newSubs.push(s); } } } - if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE) - if (newSubs.length === 1) return newSubs[0] - pf.subs = newSubs - return pf + if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE); + if (newSubs.length === 1) return newSubs[0]; + pf.subs = newSubs; + return pf; } if (pf.type === Prefilter.Type.OR) { - const newSubs = [] + const newSubs = []; for (const sub of pf.subs) { - const s = PrefilterTree.simplify(sub) + const s = PrefilterTree.simplify(sub); if (s.type === Prefilter.Type.NONE) { // If any branch of an OR has no requirements, the whole OR has no requirements - return new Prefilter(Prefilter.Type.NONE) + return new Prefilter(Prefilter.Type.NONE); } if (s.type === Prefilter.Type.OR) { - newSubs.push(...s.subs) + newSubs.push(...s.subs); } else { - newSubs.push(s) + newSubs.push(s); } } - if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE) - if (newSubs.length === 1) return newSubs[0] + if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE); + if (newSubs.length === 1) return newSubs[0]; // De-duplicate EXACT branches - const seen = new Set() - const uniqueSubs = [] + const seen = new Set(); + const uniqueSubs = []; for (const sub of newSubs) { if (sub.type === Prefilter.Type.EXACT) { if (!seen.has(sub.str)) { - seen.add(sub.str) - uniqueSubs.push(sub) + seen.add(sub.str); + uniqueSubs.push(sub); } } else { - uniqueSubs.push(sub) + uniqueSubs.push(sub); } } - pf.subs = uniqueSubs - return pf + pf.subs = uniqueSubs; + return pf; } - return pf + return pf; } } -export { Prefilter, PrefilterTree } +export { Prefilter, PrefilterTree }; diff --git a/packages/re2/src/Prog.ts b/packages/re2/src/Prog.ts index 8923354..2118e06 100644 --- a/packages/re2/src/Prog.ts +++ b/packages/re2/src/Prog.ts @@ -1,5 +1,5 @@ -import { RE2Flags } from './RE2Flags.js' -import { Inst } from './Inst.js' +import { RE2Flags } from "./RE2Flags.js"; +import { Inst } from "./Inst.js"; /** * A list of instruction pointers waiting to be patched. @@ -12,16 +12,16 @@ import { Inst } from './Inst.js' * * @see https://swtch.com/~rsc/regexp/regexp1.html */ class PatchList { - head: number - tail: number + head: number; + tail: number; /** * @param {number} head - Encoded pointer to the start of the patch list. * @param {number} tail - Encoded pointer to the end of the patch list. */ constructor(head = 0, tail = 0) { - this.head = head - this.tail = tail + this.head = head; + this.tail = tail; } } @@ -29,89 +29,93 @@ class PatchList { * A Prog is a compiled regular expression program. */ class Prog { - inst: any[] - start: number - numCap: number + inst: Inst[]; + start: number; + numCap: number; constructor() { - this.inst = [] - this.start = 0 // index of start instruction + this.inst = []; + this.start = 0; // index of start instruction // number of CAPTURE insts in re // 2 => implicit ( and ) for whole match $0 - this.numCap = 2 + this.numCap = 2; } // Returns the instruction at the specified pc. // Precondition: pc > 0 && pc < numInst(). getInst(pc: number): Inst { - return this.inst[pc] + return this.inst[pc]; } // Returns the number of instructions in this program. numInst(): number { - return this.inst.length + return this.inst.length; } // Adds a new instruction to this program, with operator |op| and |pc| equal // to |numInst()|. addInst(op: number): void { - this.inst.push(new Inst(op)) + this.inst.push(new Inst(op)); } // skipNop() follows any no-op or capturing instructions and returns the // resulting instruction. skipNop(pc: number): Inst { - let i = this.inst[pc] + let i = this.inst[pc]; while (i.op === Inst.NOP || i.op === Inst.CAPTURE) { - i = this.inst[pc] - pc = i.out + i = this.inst[pc]; + pc = i.out; } - return i + return i; } // prefix() returns a pair of a literal string that all matches for the // regexp must start with, and a boolean which is true if the prefix is the // entire match. The string is returned by appending to |prefix|. prefix(): [boolean, string] { - let prefix = '' - let i = this.skipNop(this.start) + let prefix = ""; + let i = this.skipNop(this.start); if (!Inst.isRuneOp(i.op) || i.runes.length !== 1) { - return [i.op === Inst.MATCH, prefix] + return [i.op === Inst.MATCH, prefix]; } - while (Inst.isRuneOp(i.op) && i.runes.length === 1 && (i.arg & RE2Flags.FOLD_CASE) === 0) { - prefix += String.fromCodePoint(i.runes[0]) - i = this.skipNop(i.out) + while ( + Inst.isRuneOp(i.op) && + i.runes.length === 1 && + (i.arg & RE2Flags.FOLD_CASE) === 0 + ) { + prefix += String.fromCodePoint(i.runes[0]); + i = this.skipNop(i.out); } - return [i.op === Inst.MATCH, prefix] + return [i.op === Inst.MATCH, prefix]; } // startCond() returns the leading empty-width conditions that must be true // in any match. It returns -1 (all bits set) if no matches are possible. startCond(): number { - let flag = 0 - let pc = this.start + let flag = 0; + let pc = this.start; loop: for (;;) { - const i = this.inst[pc] + const i = this.inst[pc]; switch (i.op) { case Inst.EMPTY_WIDTH: - flag |= i.arg - break + flag |= i.arg; + break; case Inst.FAIL: - return -1 + return -1; case Inst.CAPTURE: case Inst.NOP: - break + break; default: - break loop + break loop; } - pc = i.out + pc = i.out; } - return flag + return flag; } // --- Patch list --- @@ -128,41 +132,41 @@ class Prog { // at its output link. next(l: number): number { - const i = this.inst[l >> 1] + const i = this.inst[l >> 1]; if ((l & 1) === 0) { - return i.out + return i.out; } - return i.arg + return i.arg; } patch(l: PatchList, val: number): void { - let head = l.head + let head = l.head; while (head !== 0) { - const i = this.inst[head >> 1] + const i = this.inst[head >> 1]; if ((head & 1) === 0) { - head = i.out - i.out = val + head = i.out; + i.out = val; } else { - head = i.arg - i.arg = val + head = i.arg; + i.arg = val; } } } append(l1: PatchList, l2: PatchList): PatchList { - if (l1.head === 0) return l2 - if (l2.head === 0) return l1 + if (l1.head === 0) return l2; + if (l2.head === 0) return l1; // We know exactly where the tail is - const i = this.inst[l1.tail >> 1] + const i = this.inst[l1.tail >> 1]; if ((l1.tail & 1) === 0) { - i.out = l2.head + i.out = l2.head; } else { - i.arg = l2.head + i.arg = l2.head; } - return new PatchList(l1.head, l2.tail) + return new PatchList(l1.head, l2.tail); } } -export { Prog, PatchList } +export { Prog, PatchList }; diff --git a/packages/re2/src/RE2.ts b/packages/re2/src/RE2.ts index 54da490..b16254f 100644 --- a/packages/re2/src/RE2.ts +++ b/packages/re2/src/RE2.ts @@ -1,186 +1,181 @@ -import { RE2Flags } from './RE2Flags.js' -import { MachineInput } from './MachineInput.js' -import { DFA } from './DFA.js' -import { Inst } from './Inst.js' -import { PrefilterTree, Prefilter } from './Prefilter.js' -import { Compiler } from './Compiler.js' -import { Simplify } from './Simplify.js' -import { Parser } from './Parser.js' -import { Utils } from './Utils.js' +import { RE2Flags } from "./RE2Flags.js"; +import { fromUTF16, type MachineUTF16Input } from "./MachineInput.js"; +import { DFA } from "./DFA.js"; +import { Inst } from "./Inst.js"; +import { Prefilter, PrefilterTree } from "./Prefilter.js"; +import { Compiler } from "./Compiler.js"; +import { Simplify } from "./Simplify.js"; +import { Parser } from "./Parser.js"; +import { Utils } from "./Utils.js"; +import type { Prog } from "./Prog.js"; class RE2 { - expr: string - prog: any - numSubexp: number - cond: any - prefix: string | null - prefixComplete: boolean - prefixRune: number - dfa: any - prefilter: any - namedGroups: any - - // This is visible for testing. - static initTest(expr: string): RE2 { - const re2 = RE2.compile(expr) - const res = new RE2(re2.expr, re2.prog, re2.numSubexp) - res.cond = re2.cond - res.prefix = re2.prefix - res.prefixComplete = re2.prefixComplete - res.prefixRune = re2.prefixRune - res.prefilter = re2.prefilter - return res - } + expr: string; + prog: Prog; + numSubexp: number; + cond: number; + prefix: string; + prefixComplete: boolean; + prefixRune: number; + dfa: DFA; + prefilter: Prefilter | null; + namedGroups: Map; static compile(expr: string): RE2 { - return RE2.compileImpl(expr, RE2Flags.PERL) + return RE2.compileImpl(expr, RE2Flags.PERL); } static compileImpl(expr: string, mode: number): RE2 { - let re = Parser.parse(expr, mode) - const maxCap = re.maxCap() - re = Simplify.simplify(re) + return new RE2(expr, mode); + } + + constructor(expr: string, mode: number) { + let re = Parser.parse(expr, mode); + re = Simplify.simplify(re); - const prefilter = PrefilterTree.build(re) + const prefilter = PrefilterTree.build(re); - const prog = Compiler.compileRegexp(re) - const re2 = new RE2(expr, prog, maxCap) + const prog = Compiler.compileRegexp(re); - re2.prefilter = prefilter.type === Prefilter.Type.NONE ? null : prefilter + this.prefilter = prefilter.type === Prefilter.Type.NONE ? null : prefilter; - const [prefixCompl, prefixStr] = prog.prefix() - re2.prefixComplete = prefixCompl - re2.prefix = prefixStr + const [prefixCompl, prefixStr] = prog.prefix(); + this.prefixComplete = prefixCompl; + this.prefix = prefixStr; - if (re2.prefix!.length > 0) { - re2.prefixRune = re2.prefix!.codePointAt(0)! + this.prefixRune = 0; + if (this.prefix.length > 0) { + this.prefixRune = this.prefix.codePointAt(0)!; } - re2.namedGroups = re.namedGroups - return re2 - } + this.namedGroups = re.namedGroups; - constructor(expr: string, prog: any, numSubexp = 0) { - this.expr = expr - this.prog = prog - this.numSubexp = numSubexp - this.cond = prog.startCond() - this.prefix = null - this.prefixComplete = false - this.prefixRune = 0 - this.dfa = new DFA(this.prog) - this.prefilter = null + this.expr = expr; + this.prog = prog; + this.numSubexp = re.maxCap(); + this.cond = prog.startCond(); + this.dfa = new DFA(this.prog); } - matchPrefixComplete(input: any, pos: number, anchor: number, ncap: number): number[] | null { - let matchStart = -1 - let matchEnd = -1 - const pLen = input.prefixLength(this) + matchPrefixComplete( + input: any, + pos: number, + anchor: number, + ncap: number, + ): number[] | null { + let matchStart = -1; + let matchEnd = -1; + const pLen = input.prefixLength(this); if (anchor === RE2Flags.UNANCHORED) { - const idx = input.index(this, pos) - if (idx < 0) return null - matchStart = pos + idx - matchEnd = matchStart + pLen + const idx = input.index(this, pos); + if (idx < 0) return null; + matchStart = pos + idx; + matchEnd = matchStart + pLen; } else if (anchor === RE2Flags.ANCHOR_BOTH) { // Match must span [pos, endPos] exactly and equal the prefix. - if (input.endPos() - pos !== pLen) return null - const idx = input.index(this, pos) - if (idx !== 0) return null - matchStart = pos - matchEnd = pos + pLen + if (input.endPos() - pos !== pLen) return null; + const idx = input.index(this, pos); + if (idx !== 0) return null; + matchStart = pos; + matchEnd = pos + pLen; } else if (anchor === RE2Flags.ANCHOR_START) { // Match must start at pos and equal the prefix. - const idx = input.index(this, pos) - if (idx !== 0) return null - matchStart = pos - matchEnd = pos + pLen + const idx = input.index(this, pos); + if (idx !== 0) return null; + matchStart = pos; + matchEnd = pos + pLen; } - if (matchStart < 0) return null + if (matchStart < 0) return null; if (ncap > 0) { - const matchcap = new Int32Array(ncap).fill(-1) - matchcap[0] = matchStart - matchcap[1] = matchEnd - return Array.from(matchcap) + const matchcap = new Int32Array(ncap).fill(-1); + matchcap[0] = matchStart; + matchcap[1] = matchEnd; + return Array.from(matchcap); } - return [] + return []; } - executeEngine(input: any, pos: number, anchor: number, ncap: number): number[] | null { + executeEngine( + input: any, + pos: number, + anchor: number, + ncap: number, + ): number[] | null { if (this.prefixComplete && (ncap === 0 || this.numSubexp === 0)) { - return this.matchPrefixComplete(input, pos, anchor, ncap) + return this.matchPrefixComplete(input, pos, anchor, ncap); } if (this.prefilter !== null && anchor === RE2Flags.UNANCHORED) { if (!this.prefilter.eval(input, pos)) { - return null + return null; } } - const dfaResult = this.dfa.match(input, pos, anchor) + const dfaResult = this.dfa.match(input, pos, anchor); if (dfaResult !== null) { - return dfaResult ? [] : null + return dfaResult ? [] : null; } // Minimal NFA fallback for DFA state explosion - return this._nfaFallback(input, pos, anchor) ? [] : null + return this._nfaFallback(input, pos, anchor) ? [] : null; } // Minimal boolean-only NFA for when the DFA bails due to state explosion. // No captures, no thread pools — just two sets of NFA states swapped each step. - _nfaFallback(input: any, pos: number, anchor: number): boolean { - const prog = this.prog - const endPos = input.endPos() + _nfaFallback(input: MachineUTF16Input, pos: number, anchor: number): boolean { + const prog = this.prog; + const endPos = input.endPos(); const addState = ( set: Set, visited: Set, pc: number, - context: number + context: number, ): void => { - if (pc < 0 || pc >= prog.numInst() || visited.has(pc)) return - visited.add(pc) - const inst = prog.getInst(pc) + if (pc < 0 || pc >= prog.numInst() || visited.has(pc)) return; + visited.add(pc); + const inst = prog.getInst(pc); switch (inst.op) { case Inst.ALT: case Inst.ALT_MATCH: - addState(set, visited, inst.out, context) - addState(set, visited, inst.arg, context) - break + addState(set, visited, inst.out, context); + addState(set, visited, inst.arg, context); + break; case Inst.NOP: case Inst.CAPTURE: - addState(set, visited, inst.out, context) - break + addState(set, visited, inst.out, context); + break; case Inst.EMPTY_WIDTH: if ((inst.arg & ~context) === 0) { - addState(set, visited, inst.out, context) + addState(set, visited, inst.out, context); } - break + break; default: - set.add(pc) - break + set.add(pc); + break; } - } + }; - let current = new Set() - let next = new Set() + let current = new Set(); + let next = new Set(); // prevRune: the rune immediately before `pos`. See DFA.match for rationale. - let prevRune = -1 + let prevRune = -1; if (pos > 0) { - const r = input.step(pos - 1) >> 3 - if (r >= 0) prevRune = r + const r = input.step(pos - 1) >> 3; + if (r >= 0) prevRune = r; } for (let i = pos; i <= endPos; i++) { - const rune = i < endPos ? input.step(i) >> 3 : -1 - const width = i < endPos ? input.step(i) & 7 : 0 - const context = Utils.emptyOpContext(prevRune, rune) + const rune = i < endPos ? input.step(i) >> 3 : -1; + const width = i < endPos ? input.step(i) & 7 : 0; + const context = Utils.emptyOpContext(prevRune, rune); // Add start state at each position for unanchored search if (anchor === RE2Flags.UNANCHORED || i === pos) { - const visited = new Set() - addState(current, visited, prog.start, context) + const visited = new Set(); + addState(current, visited, prog.start, context); } // Check for matches before consuming. @@ -189,59 +184,59 @@ class RE2 { // matches are skipped; only the final post-loop check accepts MATCH. if (anchor !== RE2Flags.ANCHOR_BOTH) { for (const pc of current) { - const inst = prog.getInst(pc) + const inst = prog.getInst(pc); if (inst.op === Inst.MATCH) { - return true + return true; } } } - if (i >= endPos || width === 0) break + if (i >= endPos || width === 0) break; // Step: consume current character - next.clear() + next.clear(); for (const pc of current) { - const inst = prog.getInst(pc) + const inst = prog.getInst(pc); if (Inst.isRuneOp(inst.op) && inst.matchRune(rune)) { const nextContext = Utils.emptyOpContext( rune, - i + width < endPos ? input.step(i + width) >> 3 : -1 - ) - const visited = new Set() - addState(next, visited, inst.out, nextContext) + i + width < endPos ? input.step(i + width) >> 3 : -1, + ); + const visited = new Set(); + addState(next, visited, inst.out, nextContext); } } // For unanchored, add start state at next position too if (anchor === RE2Flags.UNANCHORED) { - const nextRune = i + width < endPos ? input.step(i + width) >> 3 : -1 - const nextContext = Utils.emptyOpContext(rune, nextRune) - const visited = new Set() - addState(next, visited, prog.start, nextContext) + const nextRune = i + width < endPos ? input.step(i + width) >> 3 : -1; + const nextContext = Utils.emptyOpContext(rune, nextRune); + const visited = new Set(); + addState(next, visited, prog.start, nextContext); } - prevRune = rune - ;[current, next] = [next, current] - i += width - 1 // loop increments by 1, but we advanced by width + prevRune = rune; + [current, next] = [next, current]; + i += width - 1; // loop increments by 1, but we advanced by width } // Final check for match after processing all input - const endContext = Utils.emptyOpContext(prevRune, -1) - const visited = new Set() - const finalSet = new Set() + const endContext = Utils.emptyOpContext(prevRune, -1); + const visited = new Set(); + const finalSet = new Set(); for (const pc of current) { - addState(finalSet, visited, pc, endContext) + addState(finalSet, visited, pc, endContext); } for (const pc of finalSet) { - const inst = prog.getInst(pc) - if (inst.op === Inst.MATCH) return true + const inst = prog.getInst(pc); + if (inst.op === Inst.MATCH) return true; } - return false + return false; } numberOfCapturingGroups(): number { - return this.numSubexp + return this.numSubexp; } reset(): void { @@ -249,12 +244,12 @@ class RE2 { } toString(): string { - return this.expr + return this.expr; } match(s: string): boolean { - return this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 0) !== null + return this.executeEngine(fromUTF16(s), 0, RE2Flags.UNANCHORED, 0) !== null; } } -export { RE2 } +export { RE2 }; diff --git a/packages/re2/src/RE2Flags.ts b/packages/re2/src/RE2Flags.ts index 2dea0c8..f71fe29 100644 --- a/packages/re2/src/RE2Flags.ts +++ b/packages/re2/src/RE2Flags.ts @@ -1,18 +1,18 @@ //// Parser flags. class RE2Flags { // Fold case during matching (case-insensitive). - static FOLD_CASE = 0x01 + static FOLD_CASE = 0x01; // Treat pattern as a literal string instead of a regexp. - static LITERAL = 0x02 + static LITERAL = 0x02; // Allow character classes like [^a-z] and [[:space:]] to match newline. - static CLASS_NL = 0x04 + static CLASS_NL = 0x04; // Allow '.' to match newline. - static DOT_NL = 0x08 + static DOT_NL = 0x08; // Treat ^ and $ as only matching at beginning and end of text, not // around embedded newlines. (Perl's default). - static ONE_LINE = 0x10 + static ONE_LINE = 0x10; // Make repetition operators default to non-greedy. - static NON_GREEDY = 0x20 + static NON_GREEDY = 0x20; // allow Perl extensions: // non-capturing parens - (?: ) // non-greedy operators - *? +? ?? {}? @@ -25,21 +25,25 @@ class RE2Flags { // \Q and \E to disable/enable metacharacters // (?Pexpr) for named captures // \C (any byte) is not supported. - static PERL_X = 0x40 + static PERL_X = 0x40; // Allow \p{Han}, \P{Han} for Unicode group and negation. - static UNICODE_GROUPS = 0x80 + static UNICODE_GROUPS = 0x80; // Regexp END_TEXT was $, not \z. Internal use only. - static WAS_DOLLAR = 0x100 + static WAS_DOLLAR = 0x100; - static MATCH_NL = RE2Flags.CLASS_NL | RE2Flags.DOT_NL + static MATCH_NL = RE2Flags.CLASS_NL | RE2Flags.DOT_NL; // As close to Perl as possible. - static PERL = RE2Flags.CLASS_NL | RE2Flags.ONE_LINE | RE2Flags.PERL_X | RE2Flags.UNICODE_GROUPS + static PERL = + RE2Flags.CLASS_NL | + RE2Flags.ONE_LINE | + RE2Flags.PERL_X | + RE2Flags.UNICODE_GROUPS; // POSIX syntax. - static POSIX = 0 + static POSIX = 0; //// Anchors - static UNANCHORED = 0 - static ANCHOR_START = 1 - static ANCHOR_BOTH = 2 + static UNANCHORED = 0; + static ANCHOR_START = 1; + static ANCHOR_BOTH = 2; } -export { RE2Flags } +export { RE2Flags }; diff --git a/packages/re2/src/Regexp.ts b/packages/re2/src/Regexp.ts index 3f9cb89..0370c84 100644 --- a/packages/re2/src/Regexp.ts +++ b/packages/re2/src/Regexp.ts @@ -23,86 +23,86 @@ export class Regexp { CONCAT: 17, ALTERNATE: 18, LEFT_PAREN: 19, - VERTICAL_BAR: 20 - } as const + VERTICAL_BAR: 20, + } as const; static isPseudoOp(op: number): boolean { - return op >= Regexp.Op.LEFT_PAREN + return op >= Regexp.Op.LEFT_PAREN; } static emptySubs(): Regexp[] { - return [] + return []; } static quoteIfHyphen(rune: number): string { if (rune === 0x2d) { - return '\\' + return "\\"; } - return '' + return ""; } static fromRegexp(re: Regexp): Regexp { - const regex = new Regexp(re.op) - regex.flags = re.flags - regex.subs = re.subs - regex.runes = re.runes - regex.cap = re.cap - regex.min = re.min - regex.max = re.max - regex.name = re.name - regex.namedGroups = re.namedGroups - return regex + const regex = new Regexp(re.op); + regex.flags = re.flags; + regex.subs = re.subs; + regex.runes = re.runes; + regex.cap = re.cap; + regex.min = re.min; + regex.max = re.max; + regex.name = re.name; + regex.namedGroups = re.namedGroups; + return regex; } - op: any - flags: number - subs: any[] - runes: number[] - min: number - max: number - cap: number - name: string | null - namedGroups: any + op: number; + flags: number; + subs: Regexp[]; + runes: number[]; + min: number; + max: number; + cap: number; + name: string | null; + namedGroups: Map; constructor(op: number) { - this.op = op // operator - this.flags = 0 // bitmap of parse flags + this.op = op; // operator + this.flags = 0; // bitmap of parse flags // subexpressions, if any. Never null. // subs[0] is used as the freelist. - this.subs = Regexp.emptySubs() - this.runes = [] // matched runes, for LITERAL, CHAR_CLASS - this.min = 0 // min for REPEAT - this.max = 0 // max for REPEAT - this.cap = 0 // capturing index, for CAPTURE - this.name = null // capturing name, for CAPTURE - this.namedGroups = Object.create(null) // map of group name -> capturing index + this.subs = Regexp.emptySubs(); + this.runes = []; // matched runes, for LITERAL, CHAR_CLASS + this.min = 0; // min for REPEAT + this.max = 0; // max for REPEAT + this.cap = 0; // capturing index, for CAPTURE + this.name = null; // capturing name, for CAPTURE + this.namedGroups = new Map(); } reinit(): void { - this.flags = 0 - this.subs = Regexp.emptySubs() - this.runes = [] - this.cap = 0 - this.min = 0 - this.max = 0 - this.name = null - this.namedGroups = Object.create(null) + this.flags = 0; + this.subs = Regexp.emptySubs(); + this.runes = []; + this.cap = 0; + this.min = 0; + this.max = 0; + this.name = null; + this.namedGroups = new Map(); } // maxCap() walks the regexp to find the maximum capture index. maxCap(): number { - let m = 0 + let m = 0; if (this.op === Regexp.Op.CAPTURE) { - m = this.cap + m = this.cap; } if (this.subs !== null) { for (let sub of this.subs) { - const n = sub.maxCap() + const n = sub.maxCap(); if (m < n) { - m = n + m = n; } } } - return m + return m; } } diff --git a/packages/re2/src/Simplify.ts b/packages/re2/src/Simplify.ts index 8aa7749..7491110 100644 --- a/packages/re2/src/Simplify.ts +++ b/packages/re2/src/Simplify.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from './RE2Flags.js' -import { Regexp } from './Regexp.js' -import { Unicode } from './Unicode.js' +import { RE2Flags } from "./RE2Flags.js"; +import { Regexp } from "./Regexp.js"; +import { Unicode } from "./Unicode.js"; class Simplify { // Simplify returns a regexp equivalent to re but without counted @@ -13,98 +13,104 @@ class Simplify { // may share structure with or be the original. static simplify(re: Regexp): Regexp { if (re === null) { - return null as any + return null as any; } switch (re.op) { case Regexp.Op.CAPTURE: { - const sub = Simplify.simplify(re.subs[0]) + const sub = Simplify.simplify(re.subs[0]); if (sub !== re.subs[0]) { - const nre = Regexp.fromRegexp(re) - nre.runes = [] - nre.subs = [sub] - return nre + const nre = Regexp.fromRegexp(re); + nre.runes = []; + nre.subs = [sub]; + return nre; } - return re + return re; } case Regexp.Op.CONCAT: case Regexp.Op.ALTERNATE: { - const newSubs = [] - let changed = false + const newSubs = []; + let changed = false; for (let i = 0; i < re.subs.length; i++) { - const sub = re.subs[i] - const nsub = Simplify.simplify(sub) + const sub = re.subs[i]; + const nsub = Simplify.simplify(sub); if (nsub !== sub) { - changed = true + changed = true; } if (re.op === Regexp.Op.CONCAT) { // If any part of a CONCAT is mathematically impossible, // the entire CONCAT sequence becomes impossible. if (nsub.op === Regexp.Op.NO_MATCH) { - return new Regexp(Regexp.Op.NO_MATCH) + return new Regexp(Regexp.Op.NO_MATCH); } // Drop empty 0-width match nodes entirely from sequences if (nsub.op === Regexp.Op.EMPTY_MATCH) { - changed = true - continue + changed = true; + continue; } // Flatten nested concatenations if (nsub.op === Regexp.Op.CONCAT) { - changed = true - newSubs.push(...nsub.subs) - continue + changed = true; + newSubs.push(...nsub.subs); + continue; } } else if (re.op === Regexp.Op.ALTERNATE) { // Drop impossible branches from alternations if (nsub.op === Regexp.Op.NO_MATCH) { - changed = true - continue + changed = true; + continue; } // Flatten nested alternations if (nsub.op === Regexp.Op.ALTERNATE) { - changed = true - newSubs.push(...nsub.subs) - continue + changed = true; + newSubs.push(...nsub.subs); + continue; } } - newSubs.push(nsub) + newSubs.push(nsub); } if (changed) { // If we filtered out all nodes, return the mathematically correct fallback if (newSubs.length === 0) { return new Regexp( - re.op === Regexp.Op.CONCAT ? Regexp.Op.EMPTY_MATCH : Regexp.Op.NO_MATCH - ) + re.op === Regexp.Op.CONCAT + ? Regexp.Op.EMPTY_MATCH + : Regexp.Op.NO_MATCH, + ); } // If only 1 node remains, we don't need a CONCAT/ALT container at all if (newSubs.length === 1) { - return newSubs[0] + return newSubs[0]; } - const nre = Regexp.fromRegexp(re) - nre.runes = [] - nre.subs = newSubs - return nre + const nre = Regexp.fromRegexp(re); + nre.runes = []; + nre.subs = newSubs; + return nre; } - return re + return re; } case Regexp.Op.CHAR_CLASS: { - if (re.runes === null) return re + if (re.runes === null) return re; // Empty character classes match nothing. if (re.runes.length === 0) { - return new Regexp(Regexp.Op.NO_MATCH) + return new Regexp(Regexp.Op.NO_MATCH); } // Full character classes match everything. - if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) { - return new Regexp(Regexp.Op.ANY_CHAR) + if ( + re.runes.length === 2 && + re.runes[0] === 0 && + re.runes[1] === Unicode.MAX_RUNE + ) { + return new Regexp(Regexp.Op.ANY_CHAR); } // Standard catch-all except newline if ( @@ -114,54 +120,54 @@ class Simplify { re.runes[2] === 0x0a + 1 && re.runes[3] === Unicode.MAX_RUNE ) { - return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL) + return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL); } - return re + return re; } case Regexp.Op.STAR: case Regexp.Op.PLUS: case Regexp.Op.QUEST: { - const sub = Simplify.simplify(re.subs[0]) - return Simplify.simplify1(re.op, re.flags, sub, re) + const sub = Simplify.simplify(re.subs[0]); + return Simplify.simplify1(re.op, re.flags, sub, re); } case Regexp.Op.REPEAT: { // Special special case: x{0} matches the empty string // and doesn't even need to consider x. if (re.min === 0 && re.max === 0) { - return new Regexp(Regexp.Op.EMPTY_MATCH) + return new Regexp(Regexp.Op.EMPTY_MATCH); } // The fun begins. - const sub = Simplify.simplify(re.subs[0]) + const sub = Simplify.simplify(re.subs[0]); // x{n,} means at least n matches of x. if (re.max === -1) { // Special case: x{0,} is x*. if (re.min === 0) { - return Simplify.simplify1(Regexp.Op.STAR, re.flags, sub, null) + return Simplify.simplify1(Regexp.Op.STAR, re.flags, sub, null); } // Special case: x{1,} is x+. if (re.min === 1) { - return Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null) + return Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null); } // General case: x{4,} is xxxx+. - const nre = new Regexp(Regexp.Op.CONCAT) - const subs = [] + const nre = new Regexp(Regexp.Op.CONCAT); + const subs = []; for (let i = 0; i < re.min - 1; i++) { - subs.push(sub) + subs.push(sub); } - subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null)) - nre.subs = subs.slice(0) + subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null)); + nre.subs = subs.slice(0); // Ensure newly created CONCAT is properly flattened - return Simplify.simplify(nre) + return Simplify.simplify(nre); } // Special case x{0} handled above. // Special case: x{1} is just x. if (re.min === 1 && re.max === 1) { - return sub + return sub; } // General case: x{n,m} means n copies of x and m copies of x? @@ -169,42 +175,42 @@ class Simplify { // so that x{2,5} = xx(x(x(x)?)?)? // Build leading prefix: xx. - let prefixSubs = null + let prefixSubs = null; if (re.min > 0) { - prefixSubs = [] + prefixSubs = []; for (let i = 0; i < re.min; i++) { - prefixSubs.push(sub) + prefixSubs.push(sub); } } // Build and attach suffix: (x(x(x)?)?)? if (re.max > re.min) { - let suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, sub, null) + let suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, sub, null); for (let i = re.min + 1; i < re.max; i++) { - const nre2 = new Regexp(Regexp.Op.CONCAT) - nre2.subs = [sub, suffix] - suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, nre2, null) + const nre2 = new Regexp(Regexp.Op.CONCAT); + nre2.subs = [sub, suffix]; + suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, nre2, null); } if (prefixSubs === null) { - return suffix + return suffix; } - prefixSubs.push(suffix) + prefixSubs.push(suffix); } if (prefixSubs !== null) { - const prefix = new Regexp(Regexp.Op.CONCAT) - prefix.subs = prefixSubs.slice(0) + const prefix = new Regexp(Regexp.Op.CONCAT); + prefix.subs = prefixSubs.slice(0); // Ensure newly created CONCAT is properly flattened - return Simplify.simplify(prefix) + return Simplify.simplify(prefix); } // Some degenerate case like min > max or min < max < 0. // Handle as impossible match. - return new Regexp(Regexp.Op.NO_MATCH) + return new Regexp(Regexp.Op.NO_MATCH); } } - return re + return re; } // simplify1 implements Simplify for the unary OpStar, @@ -222,23 +228,31 @@ class Simplify { // for other operators generates these unary expressions. // Letting them call simplify1 makes sure the expressions they // generate are simple. - static simplify1(op: number, flags: number, sub: Regexp, re: Regexp | null): Regexp { + static simplify1( + op: number, + flags: number, + sub: Regexp, + re: Regexp | null, + ): Regexp { // Special case: repeat the empty string as much as // you want, but it's still the empty string. if (sub.op === Regexp.Op.EMPTY_MATCH) { - return sub + return sub; } // Handle impossible targets gracefully. // e.g. Trying to match "NO_MATCH" 0 or 1 times (QUEST/STAR) evaluates to EMPTY_MATCH. if (sub.op === Regexp.Op.NO_MATCH) { - if (op === Regexp.Op.PLUS) return sub // 1+ times is impossible - return new Regexp(Regexp.Op.EMPTY_MATCH) + if (op === Regexp.Op.PLUS) return sub; // 1+ times is impossible + return new Regexp(Regexp.Op.EMPTY_MATCH); } // The operators are idempotent if the flags match. - if (op === sub.op && (flags & RE2Flags.NON_GREEDY) === (sub.flags & RE2Flags.NON_GREEDY)) { - return sub + if ( + op === sub.op && + (flags & RE2Flags.NON_GREEDY) === (sub.flags & RE2Flags.NON_GREEDY) + ) { + return sub; } if ( @@ -247,14 +261,14 @@ class Simplify { (re.flags & RE2Flags.NON_GREEDY) === (flags & RE2Flags.NON_GREEDY) && sub === re.subs[0] ) { - return re + return re; } - const nre = new Regexp(op) - nre.flags = flags - nre.subs = [sub] - return nre + const nre = new Regexp(op); + nre.flags = flags; + nre.subs = [sub]; + return nre; } } -export { Simplify } +export { Simplify }; diff --git a/packages/re2/src/Unicode.ts b/packages/re2/src/Unicode.ts index e4ace64..5819d69 100644 --- a/packages/re2/src/Unicode.ts +++ b/packages/re2/src/Unicode.ts @@ -1,50 +1,50 @@ -import { UnicodeRangeTable } from './UnicodeRangeTable.js' -import { UnicodeTables } from './UnicodeTables.js' +import { UnicodeRangeTable } from "./UnicodeRangeTable.js"; +import { UnicodeTables } from "./UnicodeTables.js"; /** * Utilities for dealing with Unicode better than JS does. */ class Unicode { // The highest legal rune value. - static MAX_RUNE = 0x10ffff + static MAX_RUNE = 0x10ffff; // The highest legal ASCII value. - static MAX_ASCII = 0x7f + static MAX_ASCII = 0x7f; // The highest legal Latin-1 value. - static MAX_LATIN1 = 0xff + static MAX_LATIN1 = 0xff; // The highest legal Basic Multilingual Plane (BMP) value. - static MAX_BMP = 0xffff + static MAX_BMP = 0xffff; // Minimum and maximum runes involved in folding. // Checked during test. - static MIN_FOLD = 0x0041 - static MAX_FOLD = 0x1e943 + static MIN_FOLD = 0x0041; + static MAX_FOLD = 0x1e943; - static MIN_HIGH_SURROGATE = 0xd800 - static MAX_HIGH_SURROGATE = 0xdbff - static MIN_LOW_SURROGATE = 0xdc00 - static MAX_LOW_SURROGATE = 0xdfff - static MIN_SUPPLEMENTARY_CODE_POINT = 0x10000 + static MIN_HIGH_SURROGATE = 0xd800; + static MAX_HIGH_SURROGATE = 0xdbff; + static MIN_LOW_SURROGATE = 0xdc00; + static MAX_LOW_SURROGATE = 0xdfff; + static MIN_SUPPLEMENTARY_CODE_POINT = 0x10000; // is32 uses binary search to test whether rune is in the specified // slice of 32-bit ranges. static is32(ranges: UnicodeRangeTable, r: number): boolean { // binary search over ranges - let lo = 0 - let hi = ranges.length + let lo = 0; + let hi = ranges.length; while (lo < hi) { - const m = lo + Math.floor((hi - lo) / 2) + const m = lo + Math.floor((hi - lo) / 2); - const rlo = ranges.getLo(m) - const rhi = ranges.getHi(m) + const rlo = ranges.getLo(m); + const rhi = ranges.getHi(m); if (rlo <= r && r <= rhi) { - const stride = ranges.getStride(m) - return (r - rlo) % stride === 0 + const stride = ranges.getStride(m); + return (r - rlo) % stride === 0; } if (r < rlo) { - hi = m + hi = m; } else { - lo = m + 1 + lo = m + 1; } } - return false + return false; } // is tests whether rune is in the specified table of ranges. @@ -52,33 +52,33 @@ class Unicode { // Fast path for Latin-1 characters using linear search. if (r <= this.MAX_LATIN1) { for (let i = 0; i < ranges.length; i++) { - const rhi = ranges.getHi(i) + const rhi = ranges.getHi(i); if (r > rhi) { - continue + continue; } - const rlo = ranges.getLo(i) + const rlo = ranges.getLo(i); if (r < rlo) { - return false + return false; } - const stride = ranges.getStride(i) - return (r - rlo) % stride === 0 + const stride = ranges.getStride(i); + return (r - rlo) % stride === 0; } - return false + return false; } // Fallback to binary search for runes outside Latin-1 - return ranges.length > 0 && r >= ranges.getLo(0) && this.is32(ranges, r) + return ranges.length > 0 && r >= ranges.getLo(0) && this.is32(ranges, r); } // isUpper reports whether the rune is an upper case letter. static isUpper(r: number): boolean { if (r <= this.MAX_LATIN1) { - const s = String.fromCodePoint(r) - return s.toUpperCase() === s && s.toLowerCase() !== s + const s = String.fromCodePoint(r); + return s.toUpperCase() === s && s.toLowerCase() !== s; } - return this.is(UnicodeTables.Upper, r) + return this.is(UnicodeTables.Upper, r); } // simpleFold iterates over Unicode code points equivalent under @@ -102,24 +102,24 @@ class Unicode { // Consult caseOrbit table for special cases (3+ element cycles, lossy // mappings like ſ→S, and Turkic-specific self-loops). if (UnicodeTables.CASE_ORBIT!.has(r)) { - return UnicodeTables.CASE_ORBIT!.get(r)! + return UnicodeTables.CASE_ORBIT!.get(r)!; } // Fallback for 2-element orbits: use raw native case conversion. // The length check rejects multi-char results (e.g., ß→SS) which // would otherwise be truncated to a non-equivalent codepoint. - const s = String.fromCodePoint(r) - const lower = s.toLowerCase() + const s = String.fromCodePoint(r); + const lower = s.toLowerCase(); if (lower.length === s.length) { - const lowerCp = lower.codePointAt(0)! - if (lowerCp !== r) return lowerCp + const lowerCp = lower.codePointAt(0)!; + if (lowerCp !== r) return lowerCp; } - const upper = s.toUpperCase() + const upper = s.toUpperCase(); if (upper.length === s.length) { - const upperCp = upper.codePointAt(0)! - if (upperCp !== r) return upperCp + const upperCp = upper.codePointAt(0)!; + if (upperCp !== r) return upperCp; } - return r + return r; } // equalsIgnoreCase performs case-insensitive equality comparison @@ -131,33 +131,33 @@ class Unicode { static equalsIgnoreCase(r1: number, r2: number): boolean { // Runes already match, or one of them is EOF if (r1 < 0 || r2 < 0 || r1 === r2) { - return true + return true; } // Fast path for the common case where both runes are ASCII characters. // Coerces both runes to lowercase if applicable. if (r1 <= this.MAX_ASCII && r2 <= this.MAX_ASCII) { if (0x41 <= r1 && r1 <= 0x5a) { - r1 |= 0x20 + r1 |= 0x20; } if (0x41 <= r2 && r2 <= 0x5a) { - r2 |= 0x20 + r2 |= 0x20; } - return r1 === r2 + return r1 === r2; } // Fall back to full Unicode case folding otherwise. // Invariant: r1 must be non-negative for (let r = this.simpleFold(r1); r !== r1; r = this.simpleFold(r)) { if (r === r2) { - return true + return true; } } - return false + return false; } } -export { Unicode } +export { Unicode }; diff --git a/packages/re2/src/UnicodeRangeTable.ts b/packages/re2/src/UnicodeRangeTable.ts index 8a9707a..b13eabe 100644 --- a/packages/re2/src/UnicodeRangeTable.ts +++ b/packages/re2/src/UnicodeRangeTable.ts @@ -1,33 +1,33 @@ class UnicodeRangeTable { - data: Uint32Array - isStride1: boolean - SIZE: number + data: Uint32Array; + isStride1: boolean; + SIZE: number; constructor(data: Uint32Array, isStride1 = false) { - this.data = data // A Uint32Array - this.isStride1 = isStride1 - this.SIZE = isStride1 ? 2 : 3 + this.data = data; // A Uint32Array + this.isStride1 = isStride1; + this.SIZE = isStride1 ? 2 : 3; } // High-performance getters that do NOT allocate memory getLo(index: number): number { - return this.data[index * this.SIZE] + return this.data[index * this.SIZE]; } getHi(index: number): number { - return this.data[index * this.SIZE + 1] + return this.data[index * this.SIZE + 1]; } getStride(index: number): number { - return this.isStride1 ? 1 : this.data[index * this.SIZE + 2] + return this.isStride1 ? 1 : this.data[index * this.SIZE + 2]; } get(index: number): number[] { - const i = index * this.SIZE - return [this.data[i], this.data[i + 1], this.getStride(index)] + const i = index * this.SIZE; + return [this.data[i], this.data[i + 1], this.getStride(index)]; } get length(): number { - return this.data.length / this.SIZE + return this.data.length / this.SIZE; } } -export { UnicodeRangeTable } +export { UnicodeRangeTable }; diff --git a/packages/re2/src/UnicodeTables.ts b/packages/re2/src/UnicodeTables.ts index 50abc14..6fa9f02 100644 --- a/packages/re2/src/UnicodeTables.ts +++ b/packages/re2/src/UnicodeTables.ts @@ -1,566 +1,600 @@ // GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT. // yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts -import { UnicodeRangeTable } from './UnicodeRangeTable.js' +import { UnicodeRangeTable } from "./UnicodeRangeTable.js"; -let _B64_MAP: Uint8Array | null = null +let _B64_MAP: Uint8Array | null = null; const getB64Map = (): Uint8Array => { if (!_B64_MAP) { - _B64_MAP = new Uint8Array(256) - const b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-' + _B64_MAP = new Uint8Array(256); + const b = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-"; for (let i = 0; i < 64; i++) { - _B64_MAP[b.charCodeAt(i)] = i + _B64_MAP[b.charCodeAt(i)] = i; } } - return _B64_MAP -} + return _B64_MAP; +}; const decodeVLQ = (str: string): number[] => { - const b64 = getB64Map() - const res: number[] = [] + const b64 = getB64Map(); + const res: number[] = []; let value = 0, - shift = 0 + shift = 0; for (let i = 0; i < str.length; i++) { - const digit = b64[str.charCodeAt(i)] - value |= (digit & 0x1f) << shift + const digit = b64[str.charCodeAt(i)]; + value |= (digit & 0x1f) << shift; if ((digit & 0x20) === 0) { - res.push(value) - value = 0 - shift = 0 + res.push(value); + value = 0; + shift = 0; } else { - shift += 5 + shift += 5; } } - return res -} + return res; +}; const decodeRanges = (str: string, isStride1: boolean): Uint32Array => { - if (str.length === 0) return new Uint32Array(0) - const res = decodeVLQ(str) - const numRanges = isStride1 ? res.length / 2 : res.length / 3 - const out = new Uint32Array(numRanges * 3) + if (str.length === 0) return new Uint32Array(0); + const res = decodeVLQ(str); + const numRanges = isStride1 ? res.length / 2 : res.length / 3; + const out = new Uint32Array(numRanges * 3); let current = 0, - resIdx = 0 + resIdx = 0; for (let i = 0; i < numRanges; i++) { - current += res[resIdx++] - out[i * 3] = current - current += res[resIdx++] - out[i * 3 + 1] = current - out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++] + current += res[resIdx++]; + out[i * 3] = current; + current += res[resIdx++]; + out[i * 3 + 1] = current; + out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++]; } - return out -} + return out; +}; const decodeOrbit = (str: string): Map => { - const res = decodeVLQ(str) - const map = new Map() - let currentKey = 0 + const res = decodeVLQ(str); + const map = new Map(); + let currentKey = 0; for (let i = 0; i < res.length; i += 2) { - currentKey += res[i] - map.set(currentKey, res[i + 1]) + currentKey += res[i]; + map.set(currentKey, res[i + 1]); } - return map -} + return map; +}; // Merges two stride-encoded UnicodeRangeTables. Expands any stride>1 // ranges to individual codepoints, then coalesces contiguous runs. const mergeRanges = (a: Uint32Array, b: Uint32Array): Uint32Array => { - if (b.length === 0) return a - if (a.length === 0) return b - const points: [number, number][] = [] + if (b.length === 0) return a; + if (a.length === 0) return b; + const points: [number, number][] = []; const push = (arr: Uint32Array): void => { for (let i = 0; i < arr.length; i += 3) { const lo = arr[i], hi = arr[i + 1], - stride = arr[i + 2] + stride = arr[i + 2]; if (stride === 1) { - points.push([lo, hi]) + points.push([lo, hi]); } else { - for (let cp = lo; cp <= hi; cp += stride) points.push([cp, cp]) + for (let cp = lo; cp <= hi; cp += stride) points.push([cp, cp]); } } - } - push(a) - push(b) - points.sort((x, y) => x[0] - y[0]) - const merged: [number, number][] = [] + }; + push(a); + push(b); + points.sort((x, y) => x[0] - y[0]); + const merged: [number, number][] = []; for (const [lo, hi] of points) { - const last = merged[merged.length - 1] + const last = merged[merged.length - 1]; if (last && last[1] + 1 >= lo) { - if (hi > last[1]) last[1] = hi + if (hi > last[1]) last[1] = hi; } else { - merged.push([lo, hi]) + merged.push([lo, hi]); } } - const out = new Uint32Array(merged.length * 3) + const out = new Uint32Array(merged.length * 3); for (let i = 0; i < merged.length; i++) { - out[i * 3] = merged[i][0] - out[i * 3 + 1] = merged[i][1] - out[i * 3 + 2] = 1 + out[i * 3] = merged[i][0]; + out[i * 3 + 1] = merged[i][1]; + out[i * 3 + 2] = 1; } - return out -} + return out; +}; // Sweeps the codepoint space using a platform property-escape regex and // returns stride-1 ranges. Surrogates are included — String.fromCodePoint // returns the lone surrogate char and platform regex matches \p{Cs} on it. const sweepPlatform = (pattern: string): Uint32Array => { - const re = new RegExp(pattern, 'u') - const ranges: number[] = [] - let start = -1 + const re = new RegExp(pattern, "u"); + const ranges: number[] = []; + let start = -1; for (let cp = 0; cp <= 0x10ffff; cp++) { if (re.test(String.fromCodePoint(cp))) { - if (start < 0) start = cp + if (start < 0) start = cp; } else if (start >= 0) { - ranges.push(start, cp - 1, 1) - start = -1 + ranges.push(start, cp - 1, 1); + start = -1; } } - if (start >= 0) ranges.push(start, 0x10ffff, 1) - return Uint32Array.from(ranges) -} + if (start >= 0) ranges.push(start, 0x10ffff, 1); + return Uint32Array.from(ranges); +}; class LazyDecoder { - private readonly initializer: Record V> - private readonly cache: Map + private readonly initializer: Record V>; + private readonly cache: Map; constructor(initializer: Record V>) { - this.initializer = initializer - this.cache = new Map() + this.initializer = initializer; + this.cache = new Map(); } has(key: string): boolean { - return key in this.initializer + return key in this.initializer; } get(key: string): V | null { - if (this.cache.has(key)) return this.cache.get(key)! - const fn = this.initializer[key] - const val = fn ? fn() : null - this.cache.set(key, val) - return val + if (this.cache.has(key)) return this.cache.get(key)!; + const fn = this.initializer[key]; + const val = fn ? fn() : null; + this.cache.set(key, val); + return val; } } class UnicodeTables { - private static _CASE_ORBIT: Map | null = null + private static _CASE_ORBIT: Map | null = null; static get CASE_ORBIT(): Map { if (!this._CASE_ORBIT) { this._CASE_ORBIT = decodeOrbit( - 'rDqpII-LsD+0HGrpIsCxJzElODoODrOnByP-Mz+HTieNj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeE1eDmpII0fjB4c+BgkHChkHKikHDjkHBkkHImkHZnkHhhGlkH9O70H-Io8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HJ48HB58HB68HB78HB88HB98HB+8HB-8HJo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HM89HLlaFs+HQwcQwdQ8-HzJpdErCBlGgphBokHjMu+pBBv+pBDy+pBBz+pBB0+pBB1+pBw5Um4+BBl4+B68cg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417CD717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27C' - ) + "rDqpII-LsD+0HGrpIsCxJzElODoODrOnByP-Mz+HTieNj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeE1eDmpII0fjB4c+BgkHChkHKikHDjkHBkkHImkHZnkHhhGlkH9O70H-Io8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HJ48HB58HB68HB78HB88HB98HB+8HB-8HJo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HM89HLlaFs+HQwcQwdQ8-HzJpdErCBlGgphBokHjMu+pBBv+pBDy+pBBz+pBB0+pBB1+pBw5Um4+BBl4+B68cg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417CD717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27C", + ); } - return this._CASE_ORBIT + return this._CASE_ORBIT; } // Additions from Unicode 15.0 → 16.0 per stable general-category name. // Merged unconditionally with platform sweep output; no-op on 16.0+ engines. - private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({ - L: () => - decodeRanges( - 'pkHBBh6iBCBNCBkvXzBB36BbBKWB9JCB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBjhDsBBz8HxmWxmWBcBDgwhCgwhCBsTB', - false - ), - LC: () => decodeRanges('pkHBh6iBCNC0rZVLV', true), - Ll: () => decodeRanges('qkHj6iBj6iBO1sZ1sZBUB', false), - Lm: () => decodeRanges('uqjChBhBx+XCBpBBB', false), - Lo: () => - decodeRanges( - 'guhCzBB36BDBCzLzLBBB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBmhDnBB18HxmWxmWBcBDgwhCgwhCBsTB', - false - ), - Lu: () => decodeRanges('pkHi6iBi6iBBOOC0rZ0rZBUB', false), - M: () => decodeRanges('3kCymhCymhCBDBvM8lB8lBBHBCDDCDBCEBCPPB47C47CkuQRB-lhBBB', false), - Mc: () => decodeRanges('49kCCBIDDCDBCBBCvavaswSCB', false), - Mn: () => decodeRanges('3kCymhCymhCBDBvM-lB-lBBEBOECPBB47CkuQkuQBKBECB-lhBBB', false), - N: () => decodeRanges('gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ', true), - Nd: () => decodeRanges('gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ', true), - P: () => decodeRanges('u6GBBwBvv8Bvv8BmzBBBCBBpgCssUssUBBBwkeAB', false), - Pd: () => decodeRanges('urjCA', true), - Po: () => decodeRanges('u6GBBwB1i+B1i+BBCCBpgCpgCssUCBwkeAB', false), - S: () => - decodeRanges('nhJCBz+CDBlPBBK-82B-82BBxzvBxzvBBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB', false), - Sm: () => decodeRanges('usjCB', true), - So: () => decodeRanges('nhJCBz+CDBlPBBKxwmDxwmDBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB', false) - }) + private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder( + { + L: () => + decodeRanges( + "pkHBBh6iBCBNCBkvXzBB36BbBKWB9JCB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBjhDsBBz8HxmWxmWBcBDgwhCgwhCBsTB", + false, + ), + LC: () => decodeRanges("pkHBh6iBCNC0rZVLV", true), + Ll: () => decodeRanges("qkHj6iBj6iBO1sZ1sZBUB", false), + Lm: () => decodeRanges("uqjChBhBx+XCBpBBB", false), + Lo: () => + decodeRanges( + "guhCzBB36BDBCzLzLBBB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBmhDnBB18HxmWxmWBcBDgwhCgwhCBsTB", + false, + ), + Lu: () => decodeRanges("pkHi6iBi6iBBOOC0rZ0rZBUB", false), + M: () => + decodeRanges( + "3kCymhCymhCBDBvM8lB8lBBHBCDDCDBCEBCPPB47C47CkuQRB-lhBBB", + false, + ), + Mc: () => decodeRanges("49kCCBIDDCDBCBBCvavaswSCB", false), + Mn: () => + decodeRanges( + "3kCymhCymhCBDBvM-lB-lBBEBOECPBB47CkuQkuQBKBECB-lhBBB", + false, + ), + N: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true), + Nd: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true), + P: () => decodeRanges("u6GBBwBvv8Bvv8BmzBBBCBBpgCssUssUBBBwkeAB", false), + Pd: () => decodeRanges("urjCA", true), + Po: () => decodeRanges("u6GBBwB1i+B1i+BBCCBpgCpgCssUCBwkeAB", false), + S: () => + decodeRanges( + "nhJCBz+CDBlPBBK-82B-82BBxzvBxzvBBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", + false, + ), + Sm: () => decodeRanges("usjCB", true), + So: () => + decodeRanges( + "nhJCBz+CDBlPBBKxwmDxwmDBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", + false, + ), + }, + ); // Additions from Unicode 15.0 → 16.0 per stable script name. private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ - Arabic: () => decodeRanges('3kCrxhCrxhCBBB4BAB', false), - Balinese: () => decodeRanges('u6GBwBA', true), + Arabic: () => decodeRanges("3kCrxhCrxhCBBB4BAB", false), + Balinese: () => decodeRanges("u6GBwBA", true), Common: () => - decodeRanges('nhJCBz+CDBlPBBKxwmDxwmDB4HBHzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB', false), - Cyrillic: () => decodeRanges('pkHB', true), - Egyptian_Hieroglyphs: () => decodeRanges('gjtC68D', true), - Han: () => decodeRanges('w-6FtT', true), - Kawi: () => decodeRanges('66nCA', true), - Khitan_Small_Script: () => decodeRanges('-njDA', true), - Latin: () => decodeRanges('r+pBCNC', true), - Myanmar: () => decodeRanges('w2lCT', true) - }) + decodeRanges( + "nhJCBz+CDBlPBBKxwmDxwmDB4HBHzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", + false, + ), + Cyrillic: () => decodeRanges("pkHB", true), + Egyptian_Hieroglyphs: () => decodeRanges("gjtC68D", true), + Han: () => decodeRanges("w-6FtT", true), + Kawi: () => decodeRanges("66nCA", true), + Khitan_Small_Script: () => decodeRanges("-njDA", true), + Latin: () => decodeRanges("r+pBCNC", true), + Myanmar: () => decodeRanges("w2lCT", true), + }); // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw // SyntaxError on these names, so platform sweep is impossible. - private static _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ - Garay: () => new UnicodeRangeTable(decodeRanges('gqjClBEcJB', true)), - Gurung_Khema: () => new UnicodeRangeTable(decodeRanges('go4C5B', true)), - Kirat_Rai: () => new UnicodeRangeTable(decodeRanges('gq7C5B', true)), - Ol_Onal: () => new UnicodeRangeTable(decodeRanges('wu5DqBFA', true)), - Sunuwar: () => new UnicodeRangeTable(decodeRanges('g+mChBPJ', true)), - Todhri: () => new UnicodeRangeTable(decodeRanges('guhCzB', true)), - Tulu_Tigalari: () => - new UnicodeRangeTable(decodeRanges('g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB', false)) - }) + private static _NEW_SCRIPTS = + /*#__PURE__*/ new LazyDecoder({ + Garay: () => new UnicodeRangeTable(decodeRanges("gqjClBEcJB", true)), + Gurung_Khema: () => new UnicodeRangeTable(decodeRanges("go4C5B", true)), + Kirat_Rai: () => new UnicodeRangeTable(decodeRanges("gq7C5B", true)), + Ol_Onal: () => new UnicodeRangeTable(decodeRanges("wu5DqBFA", true)), + Sunuwar: () => new UnicodeRangeTable(decodeRanges("g+mChBPJ", true)), + Todhri: () => new UnicodeRangeTable(decodeRanges("guhCzB", true)), + Tulu_Tigalari: () => + new UnicodeRangeTable( + decodeRanges("g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB", false), + ), + }); static readonly STABLE_CATEGORY_NAMES: ReadonlySet = new Set([ - 'C', - 'Cc', - 'Cf', - 'Cn', - 'Co', - 'Cs', - 'L', - 'LC', - 'Ll', - 'Lm', - 'Lo', - 'Lt', - 'Lu', - 'M', - 'Mc', - 'Me', - 'Mn', - 'N', - 'Nd', - 'Nl', - 'No', - 'P', - 'Pc', - 'Pd', - 'Pe', - 'Pf', - 'Pi', - 'Po', - 'Ps', - 'S', - 'Sc', - 'Sk', - 'Sm', - 'So', - 'Z', - 'Zl', - 'Zp', - 'Zs' - ]) + "C", + "Cc", + "Cf", + "Cn", + "Co", + "Cs", + "L", + "LC", + "Ll", + "Lm", + "Lo", + "Lt", + "Lu", + "M", + "Mc", + "Me", + "Mn", + "N", + "Nd", + "Nl", + "No", + "P", + "Pc", + "Pd", + "Pe", + "Pf", + "Pi", + "Po", + "Ps", + "S", + "Sc", + "Sk", + "Sm", + "So", + "Z", + "Zl", + "Zp", + "Zs", + ]); static readonly STABLE_SCRIPT_NAMES: ReadonlySet = new Set([ - 'Adlam', - 'Ahom', - 'Anatolian_Hieroglyphs', - 'Arabic', - 'Armenian', - 'Avestan', - 'Balinese', - 'Bamum', - 'Bassa_Vah', - 'Batak', - 'Bengali', - 'Bhaiksuki', - 'Bopomofo', - 'Brahmi', - 'Braille', - 'Buginese', - 'Buhid', - 'Canadian_Aboriginal', - 'Carian', - 'Caucasian_Albanian', - 'Chakma', - 'Cham', - 'Cherokee', - 'Chorasmian', - 'Common', - 'Coptic', - 'Cuneiform', - 'Cypriot', - 'Cypro_Minoan', - 'Cyrillic', - 'Deseret', - 'Devanagari', - 'Dives_Akuru', - 'Dogra', - 'Duployan', - 'Egyptian_Hieroglyphs', - 'Elbasan', - 'Elymaic', - 'Ethiopic', - 'Georgian', - 'Glagolitic', - 'Gothic', - 'Grantha', - 'Greek', - 'Gujarati', - 'Gunjala_Gondi', - 'Gurmukhi', - 'Han', - 'Hangul', - 'Hanifi_Rohingya', - 'Hanunoo', - 'Hatran', - 'Hebrew', - 'Hiragana', - 'Imperial_Aramaic', - 'Inherited', - 'Inscriptional_Pahlavi', - 'Inscriptional_Parthian', - 'Javanese', - 'Kaithi', - 'Kannada', - 'Katakana', - 'Kawi', - 'Kayah_Li', - 'Kharoshthi', - 'Khitan_Small_Script', - 'Khmer', - 'Khojki', - 'Khudawadi', - 'Lao', - 'Latin', - 'Lepcha', - 'Limbu', - 'Linear_A', - 'Linear_B', - 'Lisu', - 'Lycian', - 'Lydian', - 'Mahajani', - 'Makasar', - 'Malayalam', - 'Mandaic', - 'Manichaean', - 'Marchen', - 'Masaram_Gondi', - 'Medefaidrin', - 'Meetei_Mayek', - 'Mende_Kikakui', - 'Meroitic_Cursive', - 'Meroitic_Hieroglyphs', - 'Miao', - 'Modi', - 'Mongolian', - 'Mro', - 'Multani', - 'Myanmar', - 'Nabataean', - 'Nag_Mundari', - 'Nandinagari', - 'New_Tai_Lue', - 'Newa', - 'Nko', - 'Nushu', - 'Nyiakeng_Puachue_Hmong', - 'Ogham', - 'Ol_Chiki', - 'Old_Hungarian', - 'Old_Italic', - 'Old_North_Arabian', - 'Old_Permic', - 'Old_Persian', - 'Old_Sogdian', - 'Old_South_Arabian', - 'Old_Turkic', - 'Old_Uyghur', - 'Oriya', - 'Osage', - 'Osmanya', - 'Pahawh_Hmong', - 'Palmyrene', - 'Pau_Cin_Hau', - 'Phags_Pa', - 'Phoenician', - 'Psalter_Pahlavi', - 'Rejang', - 'Runic', - 'Samaritan', - 'Saurashtra', - 'Sharada', - 'Shavian', - 'Siddham', - 'SignWriting', - 'Sinhala', - 'Sogdian', - 'Sora_Sompeng', - 'Soyombo', - 'Sundanese', - 'Syloti_Nagri', - 'Syriac', - 'Tagalog', - 'Tagbanwa', - 'Tai_Le', - 'Tai_Tham', - 'Tai_Viet', - 'Takri', - 'Tamil', - 'Tangsa', - 'Tangut', - 'Telugu', - 'Thaana', - 'Thai', - 'Tibetan', - 'Tifinagh', - 'Tirhuta', - 'Toto', - 'Ugaritic', - 'Unknown', - 'Vai', - 'Vithkuqi', - 'Wancho', - 'Warang_Citi', - 'Yezidi', - 'Yi', - 'Zanabazar_Square' - ]) + "Adlam", + "Ahom", + "Anatolian_Hieroglyphs", + "Arabic", + "Armenian", + "Avestan", + "Balinese", + "Bamum", + "Bassa_Vah", + "Batak", + "Bengali", + "Bhaiksuki", + "Bopomofo", + "Brahmi", + "Braille", + "Buginese", + "Buhid", + "Canadian_Aboriginal", + "Carian", + "Caucasian_Albanian", + "Chakma", + "Cham", + "Cherokee", + "Chorasmian", + "Common", + "Coptic", + "Cuneiform", + "Cypriot", + "Cypro_Minoan", + "Cyrillic", + "Deseret", + "Devanagari", + "Dives_Akuru", + "Dogra", + "Duployan", + "Egyptian_Hieroglyphs", + "Elbasan", + "Elymaic", + "Ethiopic", + "Georgian", + "Glagolitic", + "Gothic", + "Grantha", + "Greek", + "Gujarati", + "Gunjala_Gondi", + "Gurmukhi", + "Han", + "Hangul", + "Hanifi_Rohingya", + "Hanunoo", + "Hatran", + "Hebrew", + "Hiragana", + "Imperial_Aramaic", + "Inherited", + "Inscriptional_Pahlavi", + "Inscriptional_Parthian", + "Javanese", + "Kaithi", + "Kannada", + "Katakana", + "Kawi", + "Kayah_Li", + "Kharoshthi", + "Khitan_Small_Script", + "Khmer", + "Khojki", + "Khudawadi", + "Lao", + "Latin", + "Lepcha", + "Limbu", + "Linear_A", + "Linear_B", + "Lisu", + "Lycian", + "Lydian", + "Mahajani", + "Makasar", + "Malayalam", + "Mandaic", + "Manichaean", + "Marchen", + "Masaram_Gondi", + "Medefaidrin", + "Meetei_Mayek", + "Mende_Kikakui", + "Meroitic_Cursive", + "Meroitic_Hieroglyphs", + "Miao", + "Modi", + "Mongolian", + "Mro", + "Multani", + "Myanmar", + "Nabataean", + "Nag_Mundari", + "Nandinagari", + "New_Tai_Lue", + "Newa", + "Nko", + "Nushu", + "Nyiakeng_Puachue_Hmong", + "Ogham", + "Ol_Chiki", + "Old_Hungarian", + "Old_Italic", + "Old_North_Arabian", + "Old_Permic", + "Old_Persian", + "Old_Sogdian", + "Old_South_Arabian", + "Old_Turkic", + "Old_Uyghur", + "Oriya", + "Osage", + "Osmanya", + "Pahawh_Hmong", + "Palmyrene", + "Pau_Cin_Hau", + "Phags_Pa", + "Phoenician", + "Psalter_Pahlavi", + "Rejang", + "Runic", + "Samaritan", + "Saurashtra", + "Sharada", + "Shavian", + "Siddham", + "SignWriting", + "Sinhala", + "Sogdian", + "Sora_Sompeng", + "Soyombo", + "Sundanese", + "Syloti_Nagri", + "Syriac", + "Tagalog", + "Tagbanwa", + "Tai_Le", + "Tai_Tham", + "Tai_Viet", + "Takri", + "Tamil", + "Tangsa", + "Tangut", + "Telugu", + "Thaana", + "Thai", + "Tibetan", + "Tifinagh", + "Tirhuta", + "Toto", + "Ugaritic", + "Unknown", + "Vai", + "Vithkuqi", + "Wancho", + "Warang_Citi", + "Yezidi", + "Yi", + "Zanabazar_Square", + ]); static readonly NEW_SCRIPT_NAMES: ReadonlySet = new Set([ - 'Garay', - 'Gurung_Khema', - 'Kirat_Rai', - 'Ol_Onal', - 'Sunuwar', - 'Todhri', - 'Tulu_Tigalari' - ]) + "Garay", + "Gurung_Khema", + "Kirat_Rai", + "Ol_Onal", + "Sunuwar", + "Todhri", + "Tulu_Tigalari", + ]); - private static _sweepCache = new Map() - private static _foldCache = new Map() + private static _sweepCache = new Map(); + private static _foldCache = new Map(); // Returns the base range table for a property name, or null if unknown. // Stable names: platform sweep + bundled delta (15.0 → 16.0). // New-in-16.0 script names: bundled full table. static buildForProperty(name: string): UnicodeRangeTable | null { if (this.NEW_SCRIPT_NAMES.has(name)) { - return this._NEW_SCRIPTS.get(name) + return this._NEW_SCRIPTS.get(name); } - let kind: 'category' | 'script' | null = null - let pattern: string | null = null + let kind: "category" | "script" | null = null; + let pattern: string | null = null; if (this.STABLE_CATEGORY_NAMES.has(name)) { - kind = 'category' - pattern = `\\p{General_Category=${name}}` + kind = "category"; + pattern = `\\p{General_Category=${name}}`; } else if (this.STABLE_SCRIPT_NAMES.has(name)) { - kind = 'script' - pattern = `\\p{Script=${name}}` - } else return null + kind = "script"; + pattern = `\\p{Script=${name}}`; + } else return null; - const cacheKey = `${kind}:${name}` - const cached = this._sweepCache.get(cacheKey) - if (cached) return cached + const cacheKey = `${kind}:${name}`; + const cached = this._sweepCache.get(cacheKey); + if (cached) return cached; - const base = sweepPlatform(pattern) + const base = sweepPlatform(pattern); const delta = - kind === 'category' ? this._DELTA_CATEGORIES.get(name) : this._DELTA_SCRIPTS.get(name) - const merged = delta ? mergeRanges(base, delta) : base - const table = new UnicodeRangeTable(merged) - this._sweepCache.set(cacheKey, table) - return table + kind === "category" + ? this._DELTA_CATEGORIES.get(name) + : this._DELTA_SCRIPTS.get(name); + const merged = delta ? mergeRanges(base, delta) : base; + const table = new UnicodeRangeTable(merged); + this._sweepCache.set(cacheKey, table); + return table; } // Computes the fold-overlay for a property name: additional runes that // fold to some rune already in the base class. Returns null if no overlay // is needed (base class is fold-stable). static buildFoldOverlay(name: string): UnicodeRangeTable | null { - const cached = this._foldCache.get(name) - if (cached !== undefined) return cached - const base = this.buildForProperty(name) + const cached = this._foldCache.get(name); + if (cached !== undefined) return cached; + const base = this.buildForProperty(name); if (!base) { - this._foldCache.set(name, null) - return null + this._foldCache.set(name, null); + return null; } const inBase = (r: number): boolean => { let lo = 0, - hi = base.length + hi = base.length; while (lo < hi) { - const m = (lo + hi) >> 1 + const m = (lo + hi) >> 1; const rlo = base.getLo(m), - rhi = base.getHi(m) - if (r < rlo) hi = m - else if (r > rhi) lo = m + 1 - else return (r - rlo) % base.getStride(m) === 0 + rhi = base.getHi(m); + if (r < rlo) hi = m; + else if (r > rhi) lo = m + 1; + else return (r - rlo) % base.getStride(m) === 0; } - return false - } + return false; + }; // Inline simpleFold to avoid circular import with Unicode.ts. - const orbit = UnicodeTables.CASE_ORBIT + const orbit = UnicodeTables.CASE_ORBIT; const simpleFold = (r: number): number => { - if (orbit.has(r)) return orbit.get(r)! - const s = String.fromCodePoint(r) - const lower = s.toLowerCase() + if (orbit.has(r)) return orbit.get(r)!; + const s = String.fromCodePoint(r); + const lower = s.toLowerCase(); if (lower.length === s.length) { - const lowerCp = lower.codePointAt(0)! - if (lowerCp !== r) return lowerCp + const lowerCp = lower.codePointAt(0)!; + if (lowerCp !== r) return lowerCp; } - const upper = s.toUpperCase() + const upper = s.toUpperCase(); if (upper.length === s.length) { - const upperCp = upper.codePointAt(0)! - if (upperCp !== r) return upperCp + const upperCp = upper.codePointAt(0)!; + if (upperCp !== r) return upperCp; } - return r - } - const extras = new Set() + return r; + }; + const extras = new Set(); for (let i = 0; i < base.length; i++) { const lo = base.getLo(i), hi = base.getHi(i), - stride = base.getStride(i) + stride = base.getStride(i); for (let cp = lo; cp <= hi; cp += stride) { - let r = simpleFold(cp) + let r = simpleFold(cp); while (r !== cp) { - if (!inBase(r)) extras.add(r) - r = simpleFold(r) + if (!inBase(r)) extras.add(r); + r = simpleFold(r); } } } if (extras.size === 0) { - this._foldCache.set(name, null) - return null + this._foldCache.set(name, null); + return null; } - const sorted = Array.from(extras).sort((a, b) => a - b) - const merged: [number, number][] = [] + const sorted = Array.from(extras).sort((a, b) => a - b); + const merged: [number, number][] = []; for (const cp of sorted) { - const last = merged[merged.length - 1] - if (last && last[1] + 1 === cp) last[1] = cp - else merged.push([cp, cp]) + const last = merged[merged.length - 1]; + if (last && last[1] + 1 === cp) last[1] = cp; + else merged.push([cp, cp]); } - const out = new Uint32Array(merged.length * 3) + const out = new Uint32Array(merged.length * 3); for (let i = 0; i < merged.length; i++) { - out[i * 3] = merged[i][0] - out[i * 3 + 1] = merged[i][1] - out[i * 3 + 2] = 1 + out[i * 3] = merged[i][0]; + out[i * 3 + 1] = merged[i][1]; + out[i * 3 + 2] = 1; } - const table = new UnicodeRangeTable(out) - this._foldCache.set(name, table) - return table + const table = new UnicodeRangeTable(out); + this._foldCache.set(name, table); + return table; } // --- Legacy API surface used by Parser --- static CATEGORIES = { - has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name) - } + has: (name: string): boolean => + UnicodeTables.STABLE_CATEGORY_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => + UnicodeTables.buildForProperty(name), + }; static SCRIPTS = { has: (name: string): boolean => - UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name) - } + UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || + UnicodeTables.NEW_SCRIPT_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => + UnicodeTables.buildForProperty(name), + }; static FOLD_CATEGORIES = { - has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name) - } + has: (name: string): boolean => + UnicodeTables.STABLE_CATEGORY_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => + UnicodeTables.buildFoldOverlay(name), + }; static FOLD_SCRIPT = { has: (name: string): boolean => - UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name) - } + UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || + UnicodeTables.NEW_SCRIPT_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => + UnicodeTables.buildFoldOverlay(name), + }; static get Upper(): UnicodeRangeTable { - return UnicodeTables.buildForProperty('Lu')! + return UnicodeTables.buildForProperty("Lu")!; } } -export { UnicodeTables } +export { UnicodeTables }; diff --git a/packages/re2/src/Utils.ts b/packages/re2/src/Utils.ts index 5a6682c..1d51f6c 100644 --- a/packages/re2/src/Utils.ts +++ b/packages/re2/src/Utils.ts @@ -1,50 +1,54 @@ -import { Unicode } from './Unicode.js' +import { Unicode } from "./Unicode.js"; /** * Various constants and helper utilities. */ class Utils { - static METACHARACTERS = '\\.+*?()|[]{}^$' + static METACHARACTERS = "\\.+*?()|[]{}^$"; //// EMPTY_* flags - static EMPTY_BEGIN_LINE = 0x01 - static EMPTY_END_LINE = 0x02 - static EMPTY_BEGIN_TEXT = 0x04 - static EMPTY_END_TEXT = 0x08 - static EMPTY_WORD_BOUNDARY = 0x10 - static EMPTY_NO_WORD_BOUNDARY = 0x20 - static EMPTY_ALL = -1 + static EMPTY_BEGIN_LINE = 0x01; + static EMPTY_END_LINE = 0x02; + static EMPTY_BEGIN_TEXT = 0x04; + static EMPTY_END_TEXT = 0x08; + static EMPTY_WORD_BOUNDARY = 0x10; + static EMPTY_NO_WORD_BOUNDARY = 0x20; + static EMPTY_ALL = -1; static emptyInts(): number[] { - return [] + return []; } // Returns true iff |c| is an ASCII letter or decimal digit. static isalnum(c: number): boolean { - return (0x30 <= c && c <= 0x39) || (0x61 <= c && c <= 0x7a) || (0x41 <= c && c <= 0x5a) + return ( + (0x30 <= c && c <= 0x39) || + (0x61 <= c && c <= 0x7a) || + (0x41 <= c && c <= 0x5a) + ); } // If |c| is an ASCII hex digit, returns its value, otherwise -1. static unhex(c: number): number { if (0x30 <= c && c <= 0x39) { - return c - 0x30 + return c - 0x30; } if (0x61 <= c && c <= 0x66) { - return c - 0x61 + 10 + return c - 0x61 + 10; } if (0x41 <= c && c <= 0x46) { - return c - 0x41 + 10 + return c - 0x41 + 10; } - return -1 + return -1; } // Returns the array of runes in the specified UTF-16 string. static stringToRunes(str: string): number[] { - return Array.from(String(str)).map((s) => s.codePointAt(0)!) + return Array.from(String(str)).map((s) => s.codePointAt(0)!); } // Returns the Java UTF-16 string containing the single rune |r|. static runeToString(r: number): string { - return String.fromCodePoint(r) + return String.fromCodePoint(r); } // isWordRune reports whether r is consider a ``word character'' @@ -52,8 +56,11 @@ class Utils { // These assertions are ASCII-only: the word characters are [A-Za-z0-9_]. static isWordRune(r: number): boolean { return ( - (0x61 <= r && r <= 0x7a) || (0x41 <= r && r <= 0x5a) || (0x30 <= r && r <= 0x39) || r === 0x5f - ) + (0x61 <= r && r <= 0x7a) || + (0x41 <= r && r <= 0x5a) || + (0x30 <= r && r <= 0x39) || + r === 0x5f + ); } // emptyOpContext returns the zero-width assertions satisfied at the position @@ -64,25 +71,25 @@ class Utils { // eslint-disable-next-line no-warning-comments // TODO(adonovan): move to Machine. static emptyOpContext(r1: number, r2: number): number { - let op = 0 + let op = 0; if (r1 < 0) { - op |= this.EMPTY_BEGIN_TEXT | this.EMPTY_BEGIN_LINE + op |= this.EMPTY_BEGIN_TEXT | this.EMPTY_BEGIN_LINE; } if (r1 === 0x0a) { - op |= this.EMPTY_BEGIN_LINE + op |= this.EMPTY_BEGIN_LINE; } if (r2 < 0) { - op |= this.EMPTY_END_TEXT | this.EMPTY_END_LINE + op |= this.EMPTY_END_TEXT | this.EMPTY_END_LINE; } if (r2 === 0x0a) { - op |= this.EMPTY_END_LINE + op |= this.EMPTY_END_LINE; } if (this.isWordRune(r1) !== this.isWordRune(r2)) { - op |= this.EMPTY_WORD_BOUNDARY + op |= this.EMPTY_WORD_BOUNDARY; } else { - op |= this.EMPTY_NO_WORD_BOUNDARY + op |= this.EMPTY_NO_WORD_BOUNDARY; } - return op + return op; } /** @@ -94,19 +101,19 @@ class Utils { */ static quoteMeta(str: string): string { return str - .split('') // A char loop is correct because all metacharacters fit in one UTF-16 code. + .split("") // A char loop is correct because all metacharacters fit in one UTF-16 code. .map((s) => { if (this.METACHARACTERS.indexOf(s) >= 0) { - return `\\${s}` + return `\\${s}`; } - return s + return s; }) - .join('') + .join(""); } static charCount(codePoint: number): number { - return codePoint > Unicode.MAX_BMP ? 2 : 1 + return codePoint > Unicode.MAX_BMP ? 2 : 1; } } -export { Utils } +export { Utils }; diff --git a/packages/re2/src/__fixtures__/find.ts b/packages/re2/src/__fixtures__/find.ts index 65f1410..1368adb 100644 --- a/packages/re2/src/__fixtures__/find.ts +++ b/packages/re2/src/__fixtures__/find.ts @@ -1,20 +1,20 @@ class Test { - pat: string - text: string - matches: number[][] + pat: string; + text: string; + matches: number[][]; constructor(pat: string, text: string, n: number, ...x: number[]) { - this.pat = pat - this.text = text - this.matches = [] + this.pat = pat; + this.text = text; + this.matches = []; if (n > 0) { - const runLength = Math.floor(x.length / n) + const runLength = Math.floor(x.length / n); for (let i = 0, j = 0; i < n; i++) { - this.matches[i] = x.slice(j, j + runLength) - j += runLength + this.matches[i] = x.slice(j, j + runLength); + j += runLength; if (j > x.length) { - throw new Error('invalid build entry') + throw new Error("invalid build entry"); } } } @@ -22,117 +22,117 @@ class Test { toString(): string { return `pat=${this.pat} text=${this.text} len=${this.matches.length} matches=${JSON.stringify( - this.matches - )}` + this.matches, + )}`; } } export const FIND_TESTS = [ - new Test('', '', 1, 0, 0), - new Test('^abcdefg', 'abcdefg', 1, 0, 7), - new Test('a+', 'baaab', 1, 1, 4), - new Test('abcd..', 'abcdef', 1, 0, 6), - new Test('a', 'a', 1, 0, 1), - new Test('x', 'y', 0), - new Test('b', 'abc', 1, 1, 2), - new Test('.', 'a', 1, 0, 1), - new Test('.*', 'abcdef', 1, 0, 6), - new Test('^', 'abcde', 1, 0, 0), - new Test('$', 'abcde', 1, 5, 5), - new Test('^abcd$', 'abcd', 1, 0, 4), - new Test("^bcd'", 'abcdef', 0), - new Test('^abcd$', 'abcde', 0), - new Test('h.*od?', 'hello\ngoodbye\n', 1, 0, 5), - new Test('a{1,5}', 'baaac', 1, 1, 4), - new Test('ac{1,25}', 'bbaaaccccdd', 1, 4, 9), - new Test('a+', 'baaab', 1, 1, 4), - new Test('a*', 'baaab', 3, 0, 0, 1, 4, 5, 5), - new Test('[a-z]+', 'abcd', 1, 0, 4), - new Test('[^a-z]+', 'ab1234cd', 1, 2, 6), - new Test('[a\\-\\]z]+', 'az]-bcz', 2, 0, 4, 6, 7), - new Test('[^\\n]+', 'abcd\n', 1, 0, 4), - new Test('[日本語]+', '日本語日本語', 1, 0, 18), - new Test('日本語+', '日本語', 1, 0, 9), - new Test('日本語+', '日本語語語語', 1, 0, 18), - new Test('()', '', 1, 0, 0, 0, 0), - new Test('(a)', 'a', 1, 0, 1, 0, 1), - new Test('(.)(.)', '日a', 1, 0, 4, 0, 3, 3, 4), - new Test('(.*)', '', 1, 0, 0, 0, 0), - new Test('(.*)', 'abcd', 1, 0, 4, 0, 4), - new Test('(..)(..)', 'abcd', 1, 0, 4, 0, 2, 2, 4), - new Test('(([^xyz]*)(d))', 'abcd', 1, 0, 4, 0, 4, 0, 3, 3, 4), - new Test('((a|b|c)*(d))', 'abcd', 1, 0, 4, 0, 4, 2, 3, 3, 4), - new Test('(((a|b|c)*)(d))', 'abcd', 1, 0, 4, 0, 4, 0, 3, 2, 3, 3, 4), - new Test('\\a\\f\\n\\r\\t\\v', '\x07\f\n\r\t\v', 1, 0, 6), - new Test('[\\a\\f\\n\\r\\t\\v]+', '\x07\f\n\r\t\v', 1, 0, 6), - new Test('a*(|(b))c*', 'aacc', 1, 0, 4, 2, 2, -1, -1), - new Test('(.*).*', 'ab', 1, 0, 2, 0, 2), - new Test('[.]', '.', 1, 0, 1), - new Test('/$', '/abc/', 1, 4, 5), - new Test('/$', '/abc', 0), + new Test("", "", 1, 0, 0), + new Test("^abcdefg", "abcdefg", 1, 0, 7), + new Test("a+", "baaab", 1, 1, 4), + new Test("abcd..", "abcdef", 1, 0, 6), + new Test("a", "a", 1, 0, 1), + new Test("x", "y", 0), + new Test("b", "abc", 1, 1, 2), + new Test(".", "a", 1, 0, 1), + new Test(".*", "abcdef", 1, 0, 6), + new Test("^", "abcde", 1, 0, 0), + new Test("$", "abcde", 1, 5, 5), + new Test("^abcd$", "abcd", 1, 0, 4), + new Test("^bcd'", "abcdef", 0), + new Test("^abcd$", "abcde", 0), + new Test("h.*od?", "hello\ngoodbye\n", 1, 0, 5), + new Test("a{1,5}", "baaac", 1, 1, 4), + new Test("ac{1,25}", "bbaaaccccdd", 1, 4, 9), + new Test("a+", "baaab", 1, 1, 4), + new Test("a*", "baaab", 3, 0, 0, 1, 4, 5, 5), + new Test("[a-z]+", "abcd", 1, 0, 4), + new Test("[^a-z]+", "ab1234cd", 1, 2, 6), + new Test("[a\\-\\]z]+", "az]-bcz", 2, 0, 4, 6, 7), + new Test("[^\\n]+", "abcd\n", 1, 0, 4), + new Test("[日本語]+", "日本語日本語", 1, 0, 18), + new Test("日本語+", "日本語", 1, 0, 9), + new Test("日本語+", "日本語語語語", 1, 0, 18), + new Test("()", "", 1, 0, 0, 0, 0), + new Test("(a)", "a", 1, 0, 1, 0, 1), + new Test("(.)(.)", "日a", 1, 0, 4, 0, 3, 3, 4), + new Test("(.*)", "", 1, 0, 0, 0, 0), + new Test("(.*)", "abcd", 1, 0, 4, 0, 4), + new Test("(..)(..)", "abcd", 1, 0, 4, 0, 2, 2, 4), + new Test("(([^xyz]*)(d))", "abcd", 1, 0, 4, 0, 4, 0, 3, 3, 4), + new Test("((a|b|c)*(d))", "abcd", 1, 0, 4, 0, 4, 2, 3, 3, 4), + new Test("(((a|b|c)*)(d))", "abcd", 1, 0, 4, 0, 4, 0, 3, 2, 3, 3, 4), + new Test("\\a\\f\\n\\r\\t\\v", "\x07\f\n\r\t\v", 1, 0, 6), + new Test("[\\a\\f\\n\\r\\t\\v]+", "\x07\f\n\r\t\v", 1, 0, 6), + new Test("a*(|(b))c*", "aacc", 1, 0, 4, 2, 2, -1, -1), + new Test("(.*).*", "ab", 1, 0, 2, 0, 2), + new Test("[.]", ".", 1, 0, 1), + new Test("/$", "/abc/", 1, 4, 5), + new Test("/$", "/abc", 0), // multiple matches - new Test('.', 'abc', 3, 0, 1, 1, 2, 2, 3), - new Test('(.)', 'abc', 3, 0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3), - new Test('.(.)', 'abcd', 2, 0, 2, 1, 2, 2, 4, 3, 4), - new Test('ab*', 'abbaab', 3, 0, 3, 3, 4, 4, 6), - new Test('a(b*)', 'abbaab', 3, 0, 3, 1, 3, 3, 4, 4, 4, 4, 6, 5, 6), + new Test(".", "abc", 3, 0, 1, 1, 2, 2, 3), + new Test("(.)", "abc", 3, 0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3), + new Test(".(.)", "abcd", 2, 0, 2, 1, 2, 2, 4, 3, 4), + new Test("ab*", "abbaab", 3, 0, 3, 3, 4, 4, 6), + new Test("a(b*)", "abbaab", 3, 0, 3, 1, 3, 3, 4, 4, 4, 4, 6, 5, 6), // fixed bugs - new Test('ab$', 'cab', 1, 1, 3), - new Test('axxb$', 'axxcb', 0), - new Test('data', 'daXY data', 1, 5, 9), - new Test('da(.)a$', 'daXY data', 1, 5, 9, 7, 8), - new Test('zx+', 'zzx', 1, 1, 3), - new Test('ab$', 'abcab', 1, 3, 5), - new Test('(aa)*$', 'a', 1, 1, 1, -1, -1), - new Test('(?:.|(?:.a))', '', 0), - new Test('(?:A(?:A|a))', 'Aa', 1, 0, 2), - new Test('(?:A|(?:A|a))', 'a', 1, 0, 1), - new Test('(a){0}', '', 1, 0, 0, -1, -1), - new Test('(?-s)(?:(?:^).)', '\n', 0), - new Test('(?s)(?:(?:^).)', '\n', 1, 0, 1), - new Test('(?:(?:^).)', '\n', 0), - new Test('\\b', 'x', 2, 0, 0, 1, 1), - new Test('\\b', 'xx', 2, 0, 0, 2, 2), - new Test('\\b', 'x y', 4, 0, 0, 1, 1, 2, 2, 3, 3), - new Test('\\b', 'xx yy', 4, 0, 0, 2, 2, 3, 3, 5, 5), - new Test('\\B', 'x', 0), - new Test('\\B', 'xx', 1, 1, 1), - new Test('\\B', 'x y', 0), - new Test('\\B', 'xx yy', 2, 1, 1, 4, 4), + new Test("ab$", "cab", 1, 1, 3), + new Test("axxb$", "axxcb", 0), + new Test("data", "daXY data", 1, 5, 9), + new Test("da(.)a$", "daXY data", 1, 5, 9, 7, 8), + new Test("zx+", "zzx", 1, 1, 3), + new Test("ab$", "abcab", 1, 3, 5), + new Test("(aa)*$", "a", 1, 1, 1, -1, -1), + new Test("(?:.|(?:.a))", "", 0), + new Test("(?:A(?:A|a))", "Aa", 1, 0, 2), + new Test("(?:A|(?:A|a))", "a", 1, 0, 1), + new Test("(a){0}", "", 1, 0, 0, -1, -1), + new Test("(?-s)(?:(?:^).)", "\n", 0), + new Test("(?s)(?:(?:^).)", "\n", 1, 0, 1), + new Test("(?:(?:^).)", "\n", 0), + new Test("\\b", "x", 2, 0, 0, 1, 1), + new Test("\\b", "xx", 2, 0, 0, 2, 2), + new Test("\\b", "x y", 4, 0, 0, 1, 1, 2, 2, 3, 3), + new Test("\\b", "xx yy", 4, 0, 0, 2, 2, 3, 3, 5, 5), + new Test("\\B", "x", 0), + new Test("\\B", "xx", 1, 1, 1), + new Test("\\B", "x y", 0), + new Test("\\B", "xx yy", 2, 1, 1, 4, 4), // RE2 tests - new Test('[^\\S\\s]', 'abcd', 0), - new Test('[^\\S[:space:]]', 'abcd', 0), - new Test('[^\\D\\d]', 'abcd', 0), - new Test('[^\\D[:digit:]]', 'abcd', 0), - new Test('(?i)\\W', 'x', 0), - new Test('(?i)\\W', 'k', 0), - new Test('(?i)\\W', 's', 0), + new Test("[^\\S\\s]", "abcd", 0), + new Test("[^\\S[:space:]]", "abcd", 0), + new Test("[^\\D\\d]", "abcd", 0), + new Test("[^\\D[:digit:]]", "abcd", 0), + new Test("(?i)\\W", "x", 0), + new Test("(?i)\\W", "k", 0), + new Test("(?i)\\W", "s", 0), // can backslash-escape any punctuation new Test( - '\\!\\"\\#\\$\\%\\&\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~', - '!"#$%&\'()*+,-./:;<=>?@[\\]^_{|}~', + "\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~", + "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~", 1, 0, - 31 + 31, ), new Test( - '[\\!\\"\\#\\$\\%\\&\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~]+', - '!"#$%&\'()*+,-./:;<=>?@[\\]^_{|}~', + "[\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~]+", + "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~", 1, 0, - 31 + 31, ), - new Test('\\`', '`', 1, 0, 1), - new Test('[\\`]+', '`', 1, 0, 1), + new Test("\\`", "`", 1, 0, 1), + new Test("[\\`]+", "`", 1, 0, 1), // long set of matches new Test( - '.', - 'qwertyuiopasdfghjklzxcvbnm1234567890', + ".", + "qwertyuiopasdfghjklzxcvbnm1234567890", 36, 0, 1, @@ -205,7 +205,7 @@ export const FIND_TESTS = [ 34, 35, 35, - 36 + 36, ), - new Test('(|a)*', 'aa', 3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2) -] + new Test("(|a)*", "aa", 3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2), +]; diff --git a/packages/re2/src/__tests__/BugHunt.test.ts b/packages/re2/src/__tests__/BugHunt.test.ts index 53f8351..4a009ef 100644 --- a/packages/re2/src/__tests__/BugHunt.test.ts +++ b/packages/re2/src/__tests__/BugHunt.test.ts @@ -6,7 +6,7 @@ import { describe, test } from "node:test"; import * as assert from "node:assert/strict"; import { RE2JS } from "../index.js"; -import { MachineInput } from "../MachineInput.js"; +import { fromUTF16 } from "../MachineInput.js"; import { RE2Flags } from "../RE2Flags.js"; import { Unicode } from "../Unicode.js"; @@ -14,15 +14,25 @@ describe("bug-hunt verification", () => { // Phase 1c: DFA.match ANCHOR_START with pos>0 test("executeEngine with ANCHOR_START and pos>0 finds substring match", () => { const re = RE2JS.compile("abc"); - const input = MachineInput.fromUTF16("xyzabc"); - const result = (re as any).re2Input.executeEngine(input, 3, RE2Flags.ANCHOR_START, 0); + const input = fromUTF16("xyzabc"); + const result = (re as any).re2Input.executeEngine( + input, + 3, + RE2Flags.ANCHOR_START, + 0, + ); assert.notStrictEqual(result, null); }); test("executeEngine with ANCHOR_START and pos>0 where pattern does not start at pos", () => { const re = RE2JS.compile("abc"); - const input = MachineInput.fromUTF16("xyzabc"); - const result = (re as any).re2Input.executeEngine(input, 1, RE2Flags.ANCHOR_START, 0); + const input = fromUTF16("xyzabc"); + const result = (re as any).re2Input.executeEngine( + input, + 1, + RE2Flags.ANCHOR_START, + 0, + ); assert.strictEqual(result, null); }); diff --git a/packages/re2/src/__tests__/CharClass.test.ts b/packages/re2/src/__tests__/CharClass.test.ts index a670d3f..39f9f64 100644 --- a/packages/re2/src/__tests__/CharClass.test.ts +++ b/packages/re2/src/__tests__/CharClass.test.ts @@ -67,7 +67,10 @@ describe(".cleanClass", () => { for (const [input, expected] of cases) { test(`input ${JSON.stringify(input)}, returns ${JSON.stringify(expected)}`, () => { - assert.deepStrictEqual(new CharClass(input).cleanClass().toArray(), expected); + assert.deepStrictEqual( + new CharClass(input).cleanClass().toArray(), + expected, + ); }); } }); @@ -91,7 +94,9 @@ describe(".appendLiteral", () => { for (const [input, literal, flags, expected] of cases) { test(`input ${JSON.stringify(input)}, literal ${JSON.stringify(literal)}, flags ${flags}, returns ${JSON.stringify(expected)}`, () => { assert.deepStrictEqual( - new CharClass(input.map(codePoint)).appendLiteral(codePoint(literal), flags).toArray(), + new CharClass(input.map(codePoint)) + .appendLiteral(codePoint(literal), flags) + .toArray(), expected.map(codePoint), ); }); @@ -103,16 +108,15 @@ describe(".appendFoldedRange", () => { [10, Unicode.MAX_FOLD + 20, [10, Unicode.MAX_FOLD + 20]], [codePoint(" "), codePoint("&"), [" ", "&"].map(codePoint)], [codePoint(" "), codePoint("C"), [" ", "C", "a", "c"].map(codePoint)], - [ - 0x1e853, - 0x1e9e4, - [0x1e944, 0x1e9e4, 0x1e853, 0x1e920, 0x1e920, 0x1e943], - ], + [0x1e853, 0x1e9e4, [0x1e944, 0x1e9e4, 0x1e853, 0x1e920, 0x1e920, 0x1e943]], ]; for (const [lo, hi, expected] of cases) { test(`lo ${lo}, hi ${hi}, returns ${JSON.stringify(expected)}`, () => { - assert.deepStrictEqual(new CharClass([]).appendFoldedRange(lo, hi).toArray(), expected); + assert.deepStrictEqual( + new CharClass([]).appendFoldedRange(lo, hi).toArray(), + expected, + ); }); } }); @@ -120,13 +124,24 @@ describe(".appendFoldedRange", () => { describe(".appendClass", () => { const cases: [number[], number[], number[]][] = [ [[], ["a", "z"].map(codePoint), ["a", "z"].map(codePoint)], - [["a", "f"].map(codePoint), ["c", "t"].map(codePoint), ["a", "t"].map(codePoint)], - [["c", "t"].map(codePoint), ["a", "f"].map(codePoint), ["a", "t"].map(codePoint)], + [ + ["a", "f"].map(codePoint), + ["c", "t"].map(codePoint), + ["a", "t"].map(codePoint), + ], + [ + ["c", "t"].map(codePoint), + ["a", "f"].map(codePoint), + ["a", "t"].map(codePoint), + ], ]; for (const [input, append, expected] of cases) { test(`input ${JSON.stringify(input)}, append ${JSON.stringify(append)}, returns ${JSON.stringify(expected)}`, () => { - assert.deepStrictEqual(new CharClass(input).appendClass(append).toArray(), expected); + assert.deepStrictEqual( + new CharClass(input).appendClass(append).toArray(), + expected, + ); }); } }); @@ -137,7 +152,14 @@ describe(".appendNegatedClass", () => { new CharClass(["d", "e"].map(codePoint)) .appendNegatedClass(["b", "f"].map(codePoint)) .toArray(), - [codePoint("d"), codePoint("e"), 0, codePoint("a"), codePoint("g"), Unicode.MAX_RUNE], + [ + codePoint("d"), + codePoint("e"), + 0, + codePoint("a"), + codePoint("g"), + Unicode.MAX_RUNE, + ], ); }); }); @@ -146,7 +168,11 @@ describe(".appendFoldedClass", () => { const s = String.fromCharCode(0x17f); const k = String.fromCharCode(0x212a); const cases: [number[], number[], number[]][] = [ - [[], ["a", "z"].map(codePoint), Utils.stringToRunes(`akAK${k}${k}lsLS${s}${s}tzTZ`)], + [ + [], + ["a", "z"].map(codePoint), + Utils.stringToRunes(`akAK${k}${k}lsLS${s}${s}tzTZ`), + ], [ ["a", "f"].map(codePoint), ["c", "t"].map(codePoint), @@ -161,7 +187,10 @@ describe(".appendFoldedClass", () => { for (const [input, append, expected] of cases) { test(`input ${JSON.stringify(input)}, append ${JSON.stringify(append)}, returns ${JSON.stringify(expected)}`, () => { - assert.deepStrictEqual(new CharClass(input).appendFoldedClass(append).toArray(), expected); + assert.deepStrictEqual( + new CharClass(input).appendFoldedClass(append).toArray(), + expected, + ); }); } }); @@ -188,7 +217,10 @@ describe(".negateClass", () => { for (const [input, expected] of cases) { test(`input ${JSON.stringify(input)}, returns ${JSON.stringify(expected)}`, () => { - assert.deepStrictEqual(new CharClass(input).negateClass().toArray(), expected); + assert.deepStrictEqual( + new CharClass(input).negateClass().toArray(), + expected, + ); }); } }); @@ -198,18 +230,29 @@ describe(".appendTable", () => { [ [], new UnicodeRangeTable( - new Uint32Array([codePoint("a"), codePoint("z"), 1, codePoint("A"), codePoint("M"), 4]), + new Uint32Array([ + codePoint("a"), + codePoint("z"), + 1, + codePoint("A"), + codePoint("M"), + 4, + ]), ), ["a", "z", "A", "A", "E", "E", "I", "I", "M", "M"].map(codePoint), ], [ [], - new UnicodeRangeTable(new Uint32Array([codePoint("Ā"), codePoint("Į"), 2])), + new UnicodeRangeTable( + new Uint32Array([codePoint("Ā"), codePoint("Į"), 2]), + ), Utils.stringToRunes("ĀĀĂĂĄĄĆĆĈĈĊĊČČĎĎĐĐĒĒĔĔĖĖĘĘĚĚĜĜĞĞĠĠĢĢĤĤĦĦĨĨĪĪĬĬĮĮ"), ], [ [], - new UnicodeRangeTable(new Uint32Array([codePoint("Ā") + 1, codePoint("Į") + 1, 2])), + new UnicodeRangeTable( + new Uint32Array([codePoint("Ā") + 1, codePoint("Į") + 1, 2]), + ), Utils.stringToRunes("āāăăąąććĉĉċċččďďđđēēĕĕėėęęěěĝĝğğġġģģĥĥħħĩĩīīĭĭįį"), ], ]; @@ -217,7 +260,10 @@ describe(".appendTable", () => { for (let i = 0; i < cases.length; i++) { const [input, table, expected] = cases[i]; test(`appendTable case ${i}`, () => { - assert.deepStrictEqual(new CharClass(input).appendTable(table).toArray(), expected); + assert.deepStrictEqual( + new CharClass(input).appendTable(table).toArray(), + expected, + ); }); } }); @@ -227,7 +273,9 @@ describe(".appendNegatedTable", () => { assert.deepStrictEqual( new CharClass([]) .appendNegatedTable( - new UnicodeRangeTable(new Uint32Array([codePoint("b"), codePoint("f"), 1])), + new UnicodeRangeTable( + new Uint32Array([codePoint("b"), codePoint("f"), 1]), + ), ) .toArray(), [0, codePoint("a"), codePoint("g"), Unicode.MAX_RUNE], @@ -238,13 +286,20 @@ describe(".appendNegatedTable", () => { describe(".appendGroup", () => { const cases: [number[], CharGroup, number[]][] = [ [[], getPerlGroups().get("\\d")!, ["0", "9"].map(codePoint)], - [[], getPerlGroups().get("\\D")!, [0, codePoint("/"), codePoint(":"), Unicode.MAX_RUNE]], + [ + [], + getPerlGroups().get("\\D")!, + [0, codePoint("/"), codePoint(":"), Unicode.MAX_RUNE], + ], ]; for (let i = 0; i < cases.length; i++) { const [input, group, expected] = cases[i]; test(`appendGroup case ${i}`, () => { - assert.deepStrictEqual(new CharClass(input).appendGroup(group, false).toArray(), expected); + assert.deepStrictEqual( + new CharClass(input).appendGroup(group, false).toArray(), + expected, + ); }); } }); diff --git a/packages/re2/src/__tests__/Codepoint.test.ts b/packages/re2/src/__tests__/Codepoint.test.ts index ac63fb4..3329a74 100644 --- a/packages/re2/src/__tests__/Codepoint.test.ts +++ b/packages/re2/src/__tests__/Codepoint.test.ts @@ -1,32 +1,32 @@ import { describe, it } from "node:test"; import * as assert from "node:assert/strict"; -import { Codepoint } from "../Codepoint.js"; +import { toLowerCase, toUpperCase } from "../Codepoint.js"; describe("Codepoint", () => { describe("ASCII fast-path memoization", () => { it("should correctly convert ASCII to upper case via lookup table", () => { - assert.strictEqual(Codepoint.toUpperCase(97), 65); // 'a' -> 'A' - assert.strictEqual(Codepoint.toUpperCase(122), 90); // 'z' -> 'Z' - assert.strictEqual(Codepoint.toUpperCase(65), 65); // 'A' -> 'A' - assert.strictEqual(Codepoint.toUpperCase(48), 48); // '0' -> '0' + assert.strictEqual(toUpperCase(97), 65); // 'a' -> 'A' + assert.strictEqual(toUpperCase(122), 90); // 'z' -> 'Z' + assert.strictEqual(toUpperCase(65), 65); // 'A' -> 'A' + assert.strictEqual(toUpperCase(48), 48); // '0' -> '0' }); it("should correctly convert ASCII to lower case via lookup table", () => { - assert.strictEqual(Codepoint.toLowerCase(65), 97); // 'A' -> 'a' - assert.strictEqual(Codepoint.toLowerCase(90), 122); // 'Z' -> 'z' - assert.strictEqual(Codepoint.toLowerCase(97), 97); // 'a' -> 'a' - assert.strictEqual(Codepoint.toLowerCase(48), 48); // '0' -> '0' + assert.strictEqual(toLowerCase(65), 97); // 'A' -> 'a' + assert.strictEqual(toLowerCase(90), 122); // 'Z' -> 'z' + assert.strictEqual(toLowerCase(97), 97); // 'a' -> 'a' + assert.strictEqual(toLowerCase(48), 48); // '0' -> '0' }); }); describe("Non-ASCII string conversion fallback", () => { it("should correctly fold non-ASCII code points", () => { // Cyrillic 'А' (U+0410) -> 'а' (U+0430) - assert.strictEqual(Codepoint.toLowerCase(0x0410), 0x0430); - assert.strictEqual(Codepoint.toUpperCase(0x0430), 0x0410); + assert.strictEqual(toLowerCase(0x0410), 0x0430); + assert.strictEqual(toUpperCase(0x0430), 0x0410); // Greek 'Ω' (U+03A9) -> 'ω' (U+03C9) - assert.strictEqual(Codepoint.toLowerCase(0x03a9), 0x03c9); + assert.strictEqual(toLowerCase(0x03a9), 0x03c9); }); }); -}); \ No newline at end of file +}); diff --git a/packages/re2/src/__tests__/DFA.test.ts b/packages/re2/src/__tests__/DFA.test.ts index 0cf5ecd..db2168e 100644 --- a/packages/re2/src/__tests__/DFA.test.ts +++ b/packages/re2/src/__tests__/DFA.test.ts @@ -4,7 +4,7 @@ import { DFA } from "../DFA.js"; import { Compiler } from "../Compiler.js"; import { Parser } from "../Parser.js"; import { RE2Flags } from "../RE2Flags.js"; -import { MachineInput } from "../MachineInput.js"; +import { fromUTF16 } from "../MachineInput.js"; const createDFA = (pattern: string, flags: number = RE2Flags.PERL): DFA => { const re = Parser.parse(pattern, flags); @@ -12,8 +12,12 @@ const createDFA = (pattern: string, flags: number = RE2Flags.PERL): DFA => { return new DFA(prog); }; -const runDFA = (dfa: DFA, text: string, anchor: number = RE2Flags.UNANCHORED): boolean | null => { - const input = MachineInput.fromUTF16(text); +const runDFA = ( + dfa: DFA, + text: string, + anchor: number = RE2Flags.UNANCHORED, +): boolean | null => { + const input = fromUTF16(text); return dfa.match(input, 0, anchor); }; diff --git a/packages/re2/src/__tests__/Exec.test.ts b/packages/re2/src/__tests__/Exec.test.ts index b567b19..eddb299 100644 --- a/packages/re2/src/__tests__/Exec.test.ts +++ b/packages/re2/src/__tests__/Exec.test.ts @@ -70,7 +70,10 @@ const parseResult = (lineno: number, res: string): number[] | null => { }; const unquote = (str: string): string => { - if ((str.startsWith("'") && str.endsWith("'")) || (str.startsWith('"') && str.endsWith('"'))) { + if ( + (str.startsWith("'") && str.endsWith("'")) || + (str.startsWith('"') && str.endsWith('"')) + ) { str = str.slice(1, -1); } @@ -118,7 +121,10 @@ const testRE2 = async (fileName: string): Promise => { continue; } - if ("A".codePointAt(0)! <= firstCodePoint && firstCodePoint <= "Z".codePointAt(0)!) { + if ( + "A".codePointAt(0)! <= firstCodePoint && + firstCodePoint <= "Z".codePointAt(0)! + ) { continue; } @@ -158,7 +164,10 @@ const testRE2 = async (fileName: string): Promise => { try { re = RE2.compile(q); } catch (e) { - if ((e as Error).message === "error parsing regexp: invalid escape sequence: `\\C`") { + if ( + (e as Error).message === + "error parsing regexp: invalid escape sequence: `\\C`" + ) { continue; } throw e; @@ -173,7 +182,8 @@ const testRE2 = async (fileName: string): Promise => { input = 0; } else if ( first === "-" || - ("0".codePointAt(0)! <= firstCodePoint && firstCodePoint <= "9".codePointAt(0)!) + ("0".codePointAt(0)! <= firstCodePoint && + firstCodePoint <= "9".codePointAt(0)!) ) { if (re === null) { continue; @@ -192,7 +202,9 @@ const testRE2 = async (fileName: string): Promise => { const res = line.split(";"); if (res.length !== 4) { - throw new Error(`${lineno}: wrong test results: ${JSON.stringify(res)}`); + throw new Error( + `${lineno}: wrong test results: ${JSON.stringify(res)}`, + ); } for (let i = 0; i < 2; i++) { diff --git a/packages/re2/src/__tests__/Parser.test.ts b/packages/re2/src/__tests__/Parser.test.ts index 266abd8..9a0b7e2 100644 --- a/packages/re2/src/__tests__/Parser.test.ts +++ b/packages/re2/src/__tests__/Parser.test.ts @@ -69,8 +69,14 @@ describe(".parse", () => { ["[[:^lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}"], ["(?i)[[:lower:]]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}"], ["(?i)[a-z]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}"], - ["(?i)[^[:lower:]]", "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}"], - ["(?i)[[:^lower:]]", "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}"], + [ + "(?i)[^[:lower:]]", + "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}", + ], + [ + "(?i)[[:^lower:]]", + "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}", + ], ["\\d", "cc{0x30-0x39}"], ["\\D", "cc{0x0-0x2f 0x3a-0x10ffff}"], ["\\s", "cc{0x9-0xa 0xc-0xd 0x20}"], @@ -78,7 +84,10 @@ describe(".parse", () => { ["\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a}"], ["\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x10ffff}"], ["(?i)\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a 0x17f 0x212a}"], - ["(?i)\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}"], + [ + "(?i)\\W", + "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}", + ], ["[^\\\\]", "cc{0x0-0x5b 0x5d-0x10ffff}"], ["\\p{Ascii}", "cc{0x0-0x7f}"], @@ -89,12 +98,18 @@ describe(".parse", () => { ["\\P{Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}"], ["\\p{^Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}"], ["\\P{^Braille}", "cc{0x2800-0x28ff}"], - ["\\pZ", "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}"], + [ + "\\pZ", + "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}", + ], ["[\\p{Braille}]", "cc{0x2800-0x28ff}"], ["[\\P{Braille}]", "cc{0x0-0x27ff 0x2900-0x10ffff}"], ["[\\p{^Braille}]", "cc{0x0-0x27ff 0x2900-0x10ffff}"], ["[\\P{^Braille}]", "cc{0x2800-0x28ff}"], - ["[\\pZ]", "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}"], + [ + "[\\pZ]", + "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}", + ], ["\\p{Lu}", mkCharClass((r) => Unicode.isUpper(r))], ["[\\p{Lu}]", mkCharClass((r) => Unicode.isUpper(r))], [ @@ -104,7 +119,11 @@ describe(".parse", () => { return true; } - for (let c = Unicode.simpleFold(r); c !== r; c = Unicode.simpleFold(c)) { + for ( + let c = Unicode.simpleFold(r); + c !== r; + c = Unicode.simpleFold(c) + ) { if (Unicode.isUpper(c)) { return true; } @@ -132,12 +151,21 @@ describe(".parse", () => { ["(?:a)", "lit{a}"], ["(?:ab)(?:cd)", "str{abcd}"], - ["(?:a+b+)(?:c+d+)", "cat{plus{lit{a}}plus{lit{b}}plus{lit{c}}plus{lit{d}}}"], - ["(?:a+|b+)|(?:c+|d+)", "alt{plus{lit{a}}plus{lit{b}}plus{lit{c}}plus{lit{d}}}"], + [ + "(?:a+b+)(?:c+d+)", + "cat{plus{lit{a}}plus{lit{b}}plus{lit{c}}plus{lit{d}}}", + ], + [ + "(?:a+|b+)|(?:c+|d+)", + "alt{plus{lit{a}}plus{lit{b}}plus{lit{c}}plus{lit{d}}}", + ], ["(?:a|b)|(?:c|d)", "cc{0x61-0x64}"], ["a|.", "dot{}"], [".|a", "dot{}"], - ["(?:[abc]|A|Z|hello|world)", "alt{cc{0x41 0x5a 0x61-0x63}str{hello}str{world}}"], + [ + "(?:[abc]|A|Z|hello|world)", + "alt{cc{0x41 0x5a 0x61-0x63}str{hello}str{world}}", + ], ["(?:[abc]|A|Z)", "cc{0x41 0x5a 0x61-0x63}"], ["\\Q+|*?{[\\E", "str{+|*?{[}"], @@ -236,7 +264,9 @@ describe("fold cases", () => { }); describe("literal cases", () => { - const cases: [string, string][] = [["(|)^$.[*+?]{5,10},\\", "str{(|)^$.[*+?]{5,10},\\}"]]; + const cases: [string, string][] = [ + ["(|)^$.[*+?]{5,10},\\", "str{(|)^$.[*+?]{5,10},\\}"], + ]; for (const [input, expected] of cases) { test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { @@ -326,8 +356,14 @@ describe("invalid regexp cases", () => { for (const input of invalidInputs) { test(`invalid ${JSON.stringify(input).slice(0, 80)} raise error`, () => { - assert.throws(() => Parser.parse(input, RE2Flags.PERL), RE2JSSyntaxException); - assert.throws(() => Parser.parse(input, RE2Flags.POSIX), RE2JSSyntaxException); + assert.throws( + () => Parser.parse(input, RE2Flags.PERL), + RE2JSSyntaxException, + ); + assert.throws( + () => Parser.parse(input, RE2Flags.POSIX), + RE2JSSyntaxException, + ); }); } @@ -350,11 +386,21 @@ describe("invalid regexp cases", () => { }); } - const invalidInPerl: string[] = ["a++", "a**", "a?*", "a+*", "a{1}*", ".{1}{2}.{3}"]; + const invalidInPerl: string[] = [ + "a++", + "a**", + "a?*", + "a+*", + "a{1}*", + ".{1}{2}.{3}", + ]; for (const input of invalidInPerl) { test(`invalid ${JSON.stringify(input)} in perl mode`, () => { - assert.throws(() => Parser.parse(input, RE2Flags.PERL), RE2JSSyntaxException); + assert.throws( + () => Parser.parse(input, RE2Flags.PERL), + RE2JSSyntaxException, + ); }); } }); diff --git a/packages/re2/src/__tests__/Prefilter.test.ts b/packages/re2/src/__tests__/Prefilter.test.ts index f20b3ad..78a182b 100644 --- a/packages/re2/src/__tests__/Prefilter.test.ts +++ b/packages/re2/src/__tests__/Prefilter.test.ts @@ -5,7 +5,7 @@ import { Simplify } from "../Simplify.js"; import { PrefilterTree, Prefilter } from "../Prefilter.js"; import { RE2Flags } from "../RE2Flags.js"; import { RE2JS } from "../index.js"; -import { MachineInput } from "../MachineInput.js"; +import { fromUTF16 } from "../MachineInput.js"; const dumpPrefilter = (pf: Prefilter | null): string => { if (!pf) return "null"; @@ -23,7 +23,10 @@ const dumpPrefilter = (pf: Prefilter | null): string => { } }; -const getPrefilterDump = (pattern: string, flags: number = RE2Flags.PERL): string => { +const getPrefilterDump = ( + pattern: string, + flags: number = RE2Flags.PERL, +): string => { let re = Parser.parse(pattern, flags); re = Simplify.simplify(re); const pf = PrefilterTree.build(re); @@ -39,10 +42,16 @@ describe("PrefilterTree.build AST Extraction", () => { ["a.*b.*c", 'AND(EXACT("a"), EXACT("b"), EXACT("c"))'], ["foo|bar", 'OR(EXACT("foo"), EXACT("bar"))'], - ["apple|banana|cherry", 'OR(EXACT("apple"), EXACT("banana"), EXACT("cherry"))'], + [ + "apple|banana|cherry", + 'OR(EXACT("apple"), EXACT("banana"), EXACT("cherry"))', + ], ["(foo|bar)baz", 'AND(OR(EXACT("foo"), EXACT("bar")), EXACT("baz"))'], - ["foo(bar|baz)qux", 'AND(EXACT("foo"), OR(EXACT("bar"), EXACT("baz")), EXACT("qux"))'], + [ + "foo(bar|baz)qux", + 'AND(EXACT("foo"), OR(EXACT("bar"), EXACT("baz")), EXACT("qux"))', + ], ["a+b", 'AND(EXACT("a"), EXACT("b"))'], ["a{2,5}b", 'AND(EXACT("a"), EXACT("a"), EXACT("b"))'], @@ -68,29 +77,35 @@ describe("PrefilterTree.build AST Extraction", () => { describe("Prefilter Evaluation (UTF-16 & UTF-8)", () => { it("correctly evaluates EXACT filters", () => { - const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("foo", RE2Flags.PERL))); + const pf = PrefilterTree.build( + Simplify.simplify(Parser.parse("foo", RE2Flags.PERL)), + ); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("bar foo baz"), 0), true); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("bar fox baz"), 0), false); + assert.strictEqual(pf.eval(fromUTF16("bar foo baz"), 0), true); + assert.strictEqual(pf.eval(fromUTF16("bar fox baz"), 0), false); }); it("correctly evaluates AND filters", () => { - const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("foo.*bar", RE2Flags.PERL))); + const pf = PrefilterTree.build( + Simplify.simplify(Parser.parse("foo.*bar", RE2Flags.PERL)), + ); - const input1 = MachineInput.fromUTF16("foo and then bar"); + const input1 = fromUTF16("foo and then bar"); assert.strictEqual(pf.eval(input1, 0), true); - const input2 = MachineInput.fromUTF16("foo and then baz"); + const input2 = fromUTF16("foo and then baz"); assert.strictEqual(pf.eval(input2, 0), false); }); it("correctly evaluates OR filters", () => { - const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("foo|bar", RE2Flags.PERL))); + const pf = PrefilterTree.build( + Simplify.simplify(Parser.parse("foo|bar", RE2Flags.PERL)), + ); - const input1 = MachineInput.fromUTF16("I have a bar"); + const input1 = fromUTF16("I have a bar"); assert.strictEqual(pf.eval(input1, 0), true); - const input2 = MachineInput.fromUTF16("I have a baz"); + const input2 = fromUTF16("I have a baz"); assert.strictEqual(pf.eval(input2, 0), false); }); }); @@ -113,27 +128,36 @@ describe("Engine Integration", () => { describe("Advanced Prefilter Evaluation", () => { it("handles complex AND/OR logic branches correctly", () => { - const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("(foo|bar)baz", RE2Flags.PERL))); - - assert.strictEqual(pf.eval(MachineInput.fromUTF16("foobaz"), 0), true); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("barbaz"), 0), true); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("foo"), 0), false); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("baz"), 0), false); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("quxbaz"), 0), false); + const pf = PrefilterTree.build( + Simplify.simplify(Parser.parse("(foo|bar)baz", RE2Flags.PERL)), + ); + + assert.strictEqual(pf.eval(fromUTF16("foobaz"), 0), true); + assert.strictEqual(pf.eval(fromUTF16("barbaz"), 0), true); + assert.strictEqual(pf.eval(fromUTF16("foo"), 0), false); + assert.strictEqual(pf.eval(fromUTF16("baz"), 0), false); + assert.strictEqual(pf.eval(fromUTF16("quxbaz"), 0), false); }); it("evaluates emojis and multi-byte unicode safely", () => { - const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("🚀.*🌕", RE2Flags.PERL))); - - assert.strictEqual(pf.eval(MachineInput.fromUTF16("To the 🚀 and then 🌕!"), 0), true); - assert.strictEqual(pf.eval(MachineInput.fromUTF16("To the 🚀 and then back!"), 0), false); + const pf = PrefilterTree.build( + Simplify.simplify(Parser.parse("🚀.*🌕", RE2Flags.PERL)), + ); + + assert.strictEqual(pf.eval(fromUTF16("To the 🚀 and then 🌕!"), 0), true); + assert.strictEqual( + pf.eval(fromUTF16("To the 🚀 and then back!"), 0), + false, + ); }); it("respects end boundaries on bounded input buffers", () => { - const pf = PrefilterTree.build(Simplify.simplify(Parser.parse("hidden", RE2Flags.PERL))); + const pf = PrefilterTree.build( + Simplify.simplify(Parser.parse("hidden", RE2Flags.PERL)), + ); const text = "visible hidden"; - const utf16Input = MachineInput.fromUTF16(text, 0, 7); + const utf16Input = fromUTF16(text, 0, 7); assert.strictEqual(pf.eval(utf16Input, 0), false); }); }); diff --git a/packages/re2/src/__tests__/RE2Compile.test.ts b/packages/re2/src/__tests__/RE2Compile.test.ts index 0e52d97..27e8611 100644 --- a/packages/re2/src/__tests__/RE2Compile.test.ts +++ b/packages/re2/src/__tests__/RE2Compile.test.ts @@ -39,7 +39,10 @@ describe(".compile", () => { ["\\p{", "invalid character class range: `\\p{`"], ["((g{2,32}|q){1,32})", "invalid repeat count: `{1,32}`"], ["((g{2,20}|q){1,20}){0,40}", "invalid repeat count: `{0,40}`"], - [[...new Array(1000)].map(() => "(xx?){1000}").join(""), "expression too large"], + [ + [...new Array(1000)].map(() => "(xx?){1000}").join(""), + "expression too large", + ], ]; for (const [input, expected] of cases) { @@ -48,7 +51,10 @@ describe(".compile", () => { RE2.compile(input); assert.strictEqual(null, expected); } catch (e) { - assert.strictEqual((e as Error).message, `error parsing regexp: ${expected}`); + assert.strictEqual( + (e as Error).message, + `error parsing regexp: ${expected}`, + ); } }); } diff --git a/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts b/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts index d1dc941..df21ee4 100644 --- a/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts +++ b/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts @@ -3,7 +3,7 @@ import * as assert from "node:assert/strict"; import { RE2 } from "../RE2.js"; import { DFA } from "../DFA.js"; import { RE2Flags } from "../RE2Flags.js"; -import { MachineInput } from "../MachineInput.js"; +import { fromUTF16 } from "../MachineInput.js"; import { Prefilter } from "../Prefilter.js"; describe("Literal Fast-Path Routing", () => { @@ -30,19 +30,19 @@ describe("Literal Fast-Path Routing", () => { const re = RE2.compile("hello"); - const matchInput = MachineInput.fromUTF16("hello"); + const matchInput = fromUTF16("hello"); assert.notStrictEqual( re.executeEngine(matchInput, 0, RE2Flags.ANCHOR_BOTH, 0), null, ); - const noMatchInput1 = MachineInput.fromUTF16("hello world"); + const noMatchInput1 = fromUTF16("hello world"); assert.strictEqual( re.executeEngine(noMatchInput1, 0, RE2Flags.ANCHOR_BOTH, 0), null, ); - const noMatchInput2 = MachineInput.fromUTF16("say hello"); + const noMatchInput2 = fromUTF16("say hello"); assert.strictEqual( re.executeEngine(noMatchInput2, 0, RE2Flags.ANCHOR_BOTH, 0), null, diff --git a/packages/re2/src/__tests__/RE2Match.test.ts b/packages/re2/src/__tests__/RE2Match.test.ts index d9eaf59..f8de46f 100644 --- a/packages/re2/src/__tests__/RE2Match.test.ts +++ b/packages/re2/src/__tests__/RE2Match.test.ts @@ -7,7 +7,10 @@ describe("match", () => { for (const testPattern of FIND_TESTS) { test(String(testPattern), () => { const re = RE2.compile(testPattern.pat); - assert.strictEqual(re.match(testPattern.text), testPattern.matches.length > 0); + assert.strictEqual( + re.match(testPattern.text), + testPattern.matches.length > 0, + ); }); } }); diff --git a/packages/re2/src/__tests__/StressErrorRecovery.test.ts b/packages/re2/src/__tests__/StressErrorRecovery.test.ts index 1f1250f..0e5048f 100644 --- a/packages/re2/src/__tests__/StressErrorRecovery.test.ts +++ b/packages/re2/src/__tests__/StressErrorRecovery.test.ts @@ -4,7 +4,10 @@ import { RE2JS } from "../index.js"; import { RE2JSSyntaxException } from "../exceptions.js"; describe("stress: parser error recovery", () => { - const compileGoodAfterBad = (badPattern: string, goodPattern: string): void => { + const compileGoodAfterBad = ( + badPattern: string, + goodPattern: string, + ): void => { assert.throws(() => RE2JS.compile(badPattern), RE2JSSyntaxException); assert.doesNotThrow(() => RE2JS.compile(goodPattern)); }; diff --git a/packages/re2/src/__tests__/UnicodeConformance.test.ts b/packages/re2/src/__tests__/UnicodeConformance.test.ts index 77aef5f..272a642 100644 --- a/packages/re2/src/__tests__/UnicodeConformance.test.ts +++ b/packages/re2/src/__tests__/UnicodeConformance.test.ts @@ -5,13 +5,17 @@ import { UnicodeTables } from "../UnicodeTables.js"; // @ts-expect-error — no types published for this package import unicodePropertyValueAliases from "unicode-property-value-aliases"; -const aliasesToNames = unicodePropertyValueAliases.get("General_Category") as Map; +const aliasesToNames = unicodePropertyValueAliases.get( + "General_Category", +) as Map; const loadCodePoints = async ( kind: "General_Category" | "Script", longName: string, ): Promise => { - const mod = await import(`@unicode/unicode-16.0.0/${kind}/${longName}/code-points.js`); + const mod = await import( + `@unicode/unicode-16.0.0/${kind}/${longName}/code-points.js` + ); return mod.default as number[]; }; diff --git a/packages/re2/src/__tests__/edge-cases.test.ts b/packages/re2/src/__tests__/edge-cases.test.ts index 45e7529..f2f9db6 100644 --- a/packages/re2/src/__tests__/edge-cases.test.ts +++ b/packages/re2/src/__tests__/edge-cases.test.ts @@ -2,7 +2,7 @@ import { describe, test, it } from "node:test"; import * as assert from "node:assert/strict"; import { RE2JS } from "../index.js"; import { RE2 } from "../RE2.js"; -import { MachineInput } from "../MachineInput.js"; +import { fromUTF16 } from "../MachineInput.js"; import { RE2Flags } from "../RE2Flags.js"; describe("Edge cases and bug hunting", () => { @@ -174,11 +174,11 @@ describe("Edge cases and bug hunting", () => { it("ANCHOR_START from pos 0 only matches if the pattern starts at 0", () => { const re = RE2.compile("abc"); assert.notStrictEqual( - re.executeEngine(MachineInput.fromUTF16("abcxyz"), 0, RE2Flags.ANCHOR_START, 0), + re.executeEngine(fromUTF16("abcxyz"), 0, RE2Flags.ANCHOR_START, 0), null, ); assert.strictEqual( - re.executeEngine(MachineInput.fromUTF16("xabc"), 0, RE2Flags.ANCHOR_START, 0), + re.executeEngine(fromUTF16("xabc"), 0, RE2Flags.ANCHOR_START, 0), null, ); }); @@ -186,15 +186,15 @@ describe("Edge cases and bug hunting", () => { it("ANCHOR_BOTH requires exact full-input match", () => { const re = RE2.compile("abc"); assert.notStrictEqual( - re.executeEngine(MachineInput.fromUTF16("abc"), 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(fromUTF16("abc"), 0, RE2Flags.ANCHOR_BOTH, 0), null, ); assert.strictEqual( - re.executeEngine(MachineInput.fromUTF16("abcd"), 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(fromUTF16("abcd"), 0, RE2Flags.ANCHOR_BOTH, 0), null, ); assert.strictEqual( - re.executeEngine(MachineInput.fromUTF16("xabc"), 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(fromUTF16("xabc"), 0, RE2Flags.ANCHOR_BOTH, 0), null, ); }); @@ -202,14 +202,44 @@ describe("Edge cases and bug hunting", () => { it("DFA and NFA agree on all anchor modes", () => { const re = RE2.compile("abc"); const inputStr = "xabcy"; - const dfaUA = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.UNANCHORED, 0); - const dfaAS = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_START, 0); - const dfaAB = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_BOTH, 0); + const dfaUA = re.executeEngine( + fromUTF16(inputStr), + 0, + RE2Flags.UNANCHORED, + 0, + ); + const dfaAS = re.executeEngine( + fromUTF16(inputStr), + 0, + RE2Flags.ANCHOR_START, + 0, + ); + const dfaAB = re.executeEngine( + fromUTF16(inputStr), + 0, + RE2Flags.ANCHOR_BOTH, + 0, + ); re.dfa.failed = true; - const nfaUA = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.UNANCHORED, 0); - const nfaAS = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_START, 0); - const nfaAB = re.executeEngine(MachineInput.fromUTF16(inputStr), 0, RE2Flags.ANCHOR_BOTH, 0); + const nfaUA = re.executeEngine( + fromUTF16(inputStr), + 0, + RE2Flags.UNANCHORED, + 0, + ); + const nfaAS = re.executeEngine( + fromUTF16(inputStr), + 0, + RE2Flags.ANCHOR_START, + 0, + ); + const nfaAB = re.executeEngine( + fromUTF16(inputStr), + 0, + RE2Flags.ANCHOR_BOTH, + 0, + ); assert.strictEqual(Boolean(nfaUA), Boolean(dfaUA)); assert.strictEqual(Boolean(nfaAS), Boolean(dfaAS)); @@ -445,18 +475,26 @@ describe("Edge cases and bug hunting", () => { it("(?...) Perl-style named group is also accepted", () => { const re = RE2JS.compile("(?\\w+)"); assert.strictEqual(re.test("hello"), true); - assert.deepStrictEqual({ ...re.namedGroups() }, { word: 1 }); + console.log(re.namedGroups()); + assert.deepStrictEqual( + re.namedGroups(), + new Map().set("word", 1), + ); }); it("namedGroups() returns group name map", () => { const re = RE2JS.compile("(?P\\w+)\\s+(?P\\w+)"); - assert.deepStrictEqual({ ...re.namedGroups() }, { first: 1, last: 2 }); + assert.deepStrictEqual( + re.namedGroups(), + new Map().set("first", 1).set("last", 2), + ); }); }); describe("Parser cache correctness (identity-based Map)", () => { it("deeply nested captures parse without height/size cache collision", () => { - const deepPattern = "(" + "(?:(?:".repeat(100) + "a" + ")*)*".repeat(100) + ")"; + const deepPattern = + "(" + "(?:(?:".repeat(100) + "a" + ")*)*".repeat(100) + ")"; assert.doesNotThrow(() => RE2JS.compile(deepPattern)); }); diff --git a/packages/re2/src/__tests__/index.test.ts b/packages/re2/src/__tests__/index.test.ts index f31f5e0..2105f0d 100644 --- a/packages/re2/src/__tests__/index.test.ts +++ b/packages/re2/src/__tests__/index.test.ts @@ -12,7 +12,10 @@ it("compile", () => { it("compile exception with duplicate groups", () => { assert.throws( () => RE2JS.compile("(?P.*)(?P.*"), - (e: Error) => e.message.includes("error parsing regexp: duplicate capture group name: `any`"), + (e: Error) => + e.message.includes( + "error parsing regexp: duplicate capture group name: `any`", + ), ); }); @@ -28,9 +31,8 @@ it("compile flags", () => { it("syntax error", () => { const compile = () => RE2JS.compile("abc("); - assert.throws( - compile, - (e: Error) => e.message.includes("error parsing regexp: missing closing ): `abc(`"), + assert.throws(compile, (e: Error) => + e.message.includes("error parsing regexp: missing closing ): `abc(`"), ); let error: RE2JSSyntaxException | null = null; @@ -42,7 +44,10 @@ it("syntax error", () => { assert.notStrictEqual(error, null); assert.strictEqual(error!.getDescription(), "missing closing )"); - assert.strictEqual(error!.message, "error parsing regexp: missing closing ): `abc(`"); + assert.strictEqual( + error!.message, + "error parsing regexp: missing closing ): `abc(`", + ); assert.strictEqual(error!.getPattern(), "abc("); }); @@ -75,7 +80,12 @@ describe("matches with flags", () => { ["^ab.*c$", RE2JS.MULTILINE, "abc", "xyz\nabc\ndef"], ["^ab.*c$", RE2JS.MULTILINE, "abc", ""], ["^ab.*c$", RE2JS.DOTALL | RE2JS.MULTILINE, "ab\nc", "AB\nc"], - ["^ab.*c$", RE2JS.DOTALL | RE2JS.MULTILINE | RE2JS.CASE_INSENSITIVE, "AB\nc", "z"], + [ + "^ab.*c$", + RE2JS.DOTALL | RE2JS.MULTILINE | RE2JS.CASE_INSENSITIVE, + "AB\nc", + "z", + ], ]; for (const [regexp, flags, match, nonMatch] of cases) { @@ -95,7 +105,11 @@ describe(".test (Unanchored DFA Match)", () => { ["(?i)foo", "FoO", true], ["^[a-z]+$", "hello", true], ["^[a-z]+$", "hello 123", false], - ["enters.*battlefield", "When this creature enters the battlefield, it deals 3 damage", true], + [ + "enters.*battlefield", + "When this creature enters the battlefield, it deals 3 damage", + true, + ], ["[0-9]+ mana", "Add 1 mana of any color", true], ]; @@ -145,18 +159,21 @@ describe("group count", () => { }); describe("named groups", () => { - const cases: [string, Record][] = [ - ["(?P\\d{2})", { foo: 1 }], - ["\\d{2}", {}], - ["hello", {}], - ["(.*)", {}], - ["(?P.*)", { any: 1 }], - ["(?P.*)(?P.*)", { foo: 1, bar: 2 }], + const cases: [string, Map][] = [ + ["(?P\\d{2})", new Map().set("foo", 1)], + ["\\d{2}", new Map()], + ["hello", new Map()], + ["(.*)", new Map()], + ["(?P.*)", new Map().set("any", 1)], + [ + "(?P.*)(?P.*)", + new Map().set("foo", 1).set("bar", 2), + ], ]; for (const [pattern, expected] of cases) { test(`pattern ${JSON.stringify(pattern)} named groups ${JSON.stringify(expected)}`, () => { - assert.deepStrictEqual({ ...RE2JS.compile(pattern).namedGroups() }, expected); + assert.deepStrictEqual(RE2JS.compile(pattern).namedGroups(), expected); }); } }); @@ -177,7 +194,9 @@ it("email regex", () => { }); it("date regex", () => { - const p = RE2JS.compile("([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])"); + const p = RE2JS.compile( + "([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])", + ); assert.strictEqual(p.matches("2023-10-12"), true); assert.strictEqual(p.matches("2023-02-02"), true); assert.strictEqual(p.matches("300"), false); diff --git a/packages/re2/src/__tests__/stability.test.ts b/packages/re2/src/__tests__/stability.test.ts index 21b5c73..73fa7fb 100644 --- a/packages/re2/src/__tests__/stability.test.ts +++ b/packages/re2/src/__tests__/stability.test.ts @@ -4,7 +4,11 @@ import { RE2JS } from "../index.js"; describe("RE2JS Stability and Anti-ReDoS Guarantees", () => { describe("Catastrophic Backtracking Immunity (ReDoS)", () => { - const assertLinearTime = (regexStr: string, inputStr: string, expectedMatch: boolean): void => { + const assertLinearTime = ( + regexStr: string, + inputStr: string, + expectedMatch: boolean, + ): void => { const re = RE2JS.compile(regexStr); const start = Date.now(); const result = re.matches(inputStr); @@ -23,7 +27,8 @@ describe("RE2JS Stability and Anti-ReDoS Guarantees", () => { }); test("Defeats OWASP Email Validation ReDoS", () => { - const emailRegex = "^([a-zA-Z0-9_.-])+@(([a-zA-Z0-9-])+.)+([a-zA-Z0-9]{2,4})+$"; + const emailRegex = + "^([a-zA-Z0-9_.-])+@(([a-zA-Z0-9-])+.)+([a-zA-Z0-9]{2,4})+$"; const maliciousEmail = `${"a".repeat(60)}@${"a".repeat(60)}.`; assertLinearTime(emailRegex, maliciousEmail, false); }); diff --git a/packages/re2/src/__utils__/chars.ts b/packages/re2/src/__utils__/chars.ts index a118f7b..1401ef8 100644 --- a/packages/re2/src/__utils__/chars.ts +++ b/packages/re2/src/__utils__/chars.ts @@ -1 +1 @@ -export const codePoint = (v: string): number => v.codePointAt(0)! +export const codePoint = (v: string): number => v.codePointAt(0)!; diff --git a/packages/re2/src/__utils__/parser.ts b/packages/re2/src/__utils__/parser.ts index 468cbef..52b8182 100644 --- a/packages/re2/src/__utils__/parser.ts +++ b/packages/re2/src/__utils__/parser.ts @@ -1,35 +1,35 @@ -import { RE2Flags } from '../RE2Flags.js' -import { Regexp } from '../Regexp.js' -import { Unicode } from '../Unicode.js' +import { RE2Flags } from "../RE2Flags.js"; +import { Regexp } from "../Regexp.js"; +import { Unicode } from "../Unicode.js"; const OP_NAMES = new Map([ - [Regexp.Op.NO_MATCH, 'no'], - [Regexp.Op.EMPTY_MATCH, 'emp'], - [Regexp.Op.LITERAL, 'lit'], - [Regexp.Op.CHAR_CLASS, 'cc'], - [Regexp.Op.ANY_CHAR_NOT_NL, 'dnl'], - [Regexp.Op.ANY_CHAR, 'dot'], - [Regexp.Op.BEGIN_LINE, 'bol'], - [Regexp.Op.END_LINE, 'eol'], - [Regexp.Op.BEGIN_TEXT, 'bot'], - [Regexp.Op.END_TEXT, 'eot'], - [Regexp.Op.WORD_BOUNDARY, 'wb'], - [Regexp.Op.NO_WORD_BOUNDARY, 'nwb'], - [Regexp.Op.CAPTURE, 'cap'], - [Regexp.Op.STAR, 'star'], - [Regexp.Op.PLUS, 'plus'], - [Regexp.Op.QUEST, 'que'], - [Regexp.Op.REPEAT, 'rep'], - [Regexp.Op.CONCAT, 'cat'], - [Regexp.Op.ALTERNATE, 'alt'] -]) + [Regexp.Op.NO_MATCH, "no"], + [Regexp.Op.EMPTY_MATCH, "emp"], + [Regexp.Op.LITERAL, "lit"], + [Regexp.Op.CHAR_CLASS, "cc"], + [Regexp.Op.ANY_CHAR_NOT_NL, "dnl"], + [Regexp.Op.ANY_CHAR, "dot"], + [Regexp.Op.BEGIN_LINE, "bol"], + [Regexp.Op.END_LINE, "eol"], + [Regexp.Op.BEGIN_TEXT, "bot"], + [Regexp.Op.END_TEXT, "eot"], + [Regexp.Op.WORD_BOUNDARY, "wb"], + [Regexp.Op.NO_WORD_BOUNDARY, "nwb"], + [Regexp.Op.CAPTURE, "cap"], + [Regexp.Op.STAR, "star"], + [Regexp.Op.PLUS, "plus"], + [Regexp.Op.QUEST, "que"], + [Regexp.Op.REPEAT, "rep"], + [Regexp.Op.CONCAT, "cat"], + [Regexp.Op.ALTERNATE, "alt"], +]); export const dumpRegexp = (re: Regexp): string => { - let b = '' + let b = ""; if (!OP_NAMES.has(re.op)) { - b += `op${re.op}` + b += `op${re.op}`; } else { - const name = OP_NAMES.get(re.op)! + const name = OP_NAMES.get(re.op)!; switch (re.op) { case Regexp.Op.STAR: @@ -37,104 +37,104 @@ export const dumpRegexp = (re: Regexp): string => { case Regexp.Op.QUEST: case Regexp.Op.REPEAT: if ((re.flags & RE2Flags.NON_GREEDY) !== 0) { - b += 'n' + b += "n"; } - b += name - break + b += name; + break; case Regexp.Op.LITERAL: if (re.runes.length > 1) { - b += 'str' + b += "str"; } else { - b += 'lit' + b += "lit"; } if ((re.flags & RE2Flags.FOLD_CASE) !== 0) { for (let r of re.runes) { if (Unicode.simpleFold(r) !== r) { - b += 'fold' - break + b += "fold"; + break; } } } - break + break; default: - b += name - break + b += name; + break; } } - b += '{' + b += "{"; switch (re.op) { case Regexp.Op.END_TEXT: if ((re.flags & RE2Flags.WAS_DOLLAR) === 0) { - b += '\\z' + b += "\\z"; } - break + break; case Regexp.Op.LITERAL: for (let r of re.runes) { - b += String.fromCodePoint(r) + b += String.fromCodePoint(r); } - break + break; case Regexp.Op.CONCAT: case Regexp.Op.ALTERNATE: for (let sub of re.subs) { - b += dumpRegexp(sub) + b += dumpRegexp(sub); } - break + break; case Regexp.Op.STAR: case Regexp.Op.PLUS: case Regexp.Op.QUEST: - b += dumpRegexp(re.subs[0]) - break + b += dumpRegexp(re.subs[0]); + break; case Regexp.Op.REPEAT: - b += `${re.min},${re.max}` - b += ' ' - b += dumpRegexp(re.subs[0]) - break + b += `${re.min},${re.max}`; + b += " "; + b += dumpRegexp(re.subs[0]); + break; case Regexp.Op.CAPTURE: if (re.name !== null && re.name.length > 0) { - b += re.name - b += ':' + b += re.name; + b += ":"; } - b += dumpRegexp(re.subs[0]) - break + b += dumpRegexp(re.subs[0]); + break; case Regexp.Op.CHAR_CLASS: { - let sep = '' + let sep = ""; for (let i = 0; i < re.runes.length; i += 2) { - b += sep - sep = ' ' - let lo = re.runes[i] - let hi = re.runes[i + 1] + b += sep; + sep = " "; + let lo = re.runes[i]; + let hi = re.runes[i + 1]; if (lo === hi) { - b += `0x${lo.toString(16)}` + b += `0x${lo.toString(16)}`; } else { - b += `0x${lo.toString(16)}-0x${hi.toString(16)}` + b += `0x${lo.toString(16)}-0x${hi.toString(16)}`; } } - break + break; } } - b += '}' - return b -} + b += "}"; + return b; +}; export const mkCharClass = (f: (r: number) => boolean): string => { - const re = new Regexp(Regexp.Op.CHAR_CLASS) - let runes: number[] = [] - let lo = -1 + const re = new Regexp(Regexp.Op.CHAR_CLASS); + let runes: number[] = []; + let lo = -1; for (let i = 0; i <= Unicode.MAX_RUNE; i++) { if (f(i)) { if (lo < 0) { - lo = i + lo = i; } } else if (lo >= 0) { - runes = [...runes, lo, i - 1] - lo = -1 + runes = [...runes, lo, i - 1]; + lo = -1; } } if (lo >= 0) { - runes = [...runes, lo, Unicode.MAX_RUNE] + runes = [...runes, lo, Unicode.MAX_RUNE]; } - re.runes = runes - return dumpRegexp(re) -} + re.runes = runes; + return dumpRegexp(re); +}; diff --git a/packages/re2/src/__utils__/unicode.ts b/packages/re2/src/__utils__/unicode.ts index f862197..9c57dfc 100644 --- a/packages/re2/src/__utils__/unicode.ts +++ b/packages/re2/src/__utils__/unicode.ts @@ -1,14 +1,14 @@ -const encoder = new TextEncoder() +const encoder = new TextEncoder(); export const utf16IndicesToUtf8 = (idx16: number[], text: string): number[] => { - const idx8: number[] = new Array(idx16.length) + const idx8: number[] = new Array(idx16.length); for (let i = 0; i < idx16.length; ++i) { if (idx16[i] === -1) { - idx8[i] = -1 + idx8[i] = -1; } else { - const subText = text.substring(0, idx16[i]) - idx8[i] = encoder.encode(subText).length + const subText = text.substring(0, idx16[i]); + idx8[i] = encoder.encode(subText).length; } } - return idx8 -} + return idx8; +}; diff --git a/packages/re2/src/exceptions.ts b/packages/re2/src/exceptions.ts index ef4eb6b..9cbc94a 100644 --- a/packages/re2/src/exceptions.ts +++ b/packages/re2/src/exceptions.ts @@ -1,8 +1,8 @@ class RE2JSException extends Error { /** @param {string} message */ constructor(message: string) { - super(message) - this.name = 'RE2JSException' + super(message); + this.name = "RE2JSException"; } } @@ -10,26 +10,26 @@ class RE2JSException extends Error { * An exception thrown by the parser if the pattern was invalid. */ class RE2JSSyntaxException extends RE2JSException { - error: string - input: string | null + error: string; + input: string | null; /** * @param {string} error * @param {string|null} [input=null] */ constructor(error: string, input: string | null = null) { - let message = `error parsing regexp: ${error}` + let message = `error parsing regexp: ${error}`; if (input) { - message += `: \`${input}\`` + message += `: \`${input}\``; } - super(message) - this.name = 'RE2JSSyntaxException' - this.message = message + super(message); + this.name = "RE2JSSyntaxException"; + this.message = message; /** @type {string} */ - this.error = error + this.error = error; /** @type {string|null} */ - this.input = input + this.input = input; } /** @@ -37,7 +37,7 @@ class RE2JSSyntaxException extends RE2JSException { * @returns {string} */ getDescription(): string { - return this.error + return this.error; } /** @@ -45,7 +45,7 @@ class RE2JSSyntaxException extends RE2JSException { * @returns {string|null} */ getPattern(): string | null { - return this.input + return this.input; } } @@ -55,8 +55,8 @@ class RE2JSSyntaxException extends RE2JSException { class RE2JSCompileException extends RE2JSException { /** @param {string} message */ constructor(message: string) { - super(message) - this.name = 'RE2JSCompileException' + super(message); + this.name = "RE2JSCompileException"; } } @@ -66,8 +66,8 @@ class RE2JSCompileException extends RE2JSException { class RE2JSGroupException extends RE2JSException { /** @param {string} message */ constructor(message: string) { - super(message) - this.name = 'RE2JSGroupException' + super(message); + this.name = "RE2JSGroupException"; } } @@ -77,8 +77,8 @@ class RE2JSGroupException extends RE2JSException { class RE2JSFlagsException extends RE2JSException { /** @param {string} message */ constructor(message: string) { - super(message) - this.name = 'RE2JSFlagsException' + super(message); + this.name = "RE2JSFlagsException"; } } @@ -88,8 +88,8 @@ class RE2JSFlagsException extends RE2JSException { class RE2JSInternalException extends RE2JSException { /** @param {string} message */ constructor(message: string) { - super(message) - this.name = 'RE2JSInternalException' + super(message); + this.name = "RE2JSInternalException"; } } @@ -99,5 +99,5 @@ export { RE2JSCompileException, RE2JSGroupException, RE2JSFlagsException, - RE2JSInternalException -} + RE2JSInternalException, +}; diff --git a/packages/re2/src/index.ts b/packages/re2/src/index.ts index 4e76b8e..28d5b37 100644 --- a/packages/re2/src/index.ts +++ b/packages/re2/src/index.ts @@ -1,15 +1,15 @@ -import { RE2Flags } from './RE2Flags.js' -import { MachineInput } from './MachineInput.js' -import { RE2 } from './RE2.js' -import { Utils } from './Utils.js' +import { RE2Flags } from "./RE2Flags.js"; +import { fromUTF16 } from "./MachineInput.js"; +import { RE2 } from "./RE2.js"; +import { Utils } from "./Utils.js"; import { - RE2JSException, - RE2JSSyntaxException, RE2JSCompileException, - RE2JSGroupException, + RE2JSException, RE2JSFlagsException, - RE2JSInternalException -} from './exceptions.js' + RE2JSGroupException, + RE2JSInternalException, + RE2JSSyntaxException, +} from "./exceptions.js"; /** * A compiled representation of an RE2 regular expression @@ -17,27 +17,27 @@ import { * @class */ class RE2JS { - patternInput: string - flagsInput: number - re2Input: any + patternInput: string; + flagsInput: number; + re2Input: RE2; /** * Flag: case insensitive matching. */ - static CASE_INSENSITIVE = 1 + static CASE_INSENSITIVE = 1; /** * Flag: dot ({@code .}) matches all characters, including newline. */ - static DOTALL = 2 + static DOTALL = 2; /** * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just * beginning and end of input. */ - static MULTILINE = 4 + static MULTILINE = 4; /** * Flag: Unicode groups (e.g. {@code \p{Greek}} ) will be syntax errors. */ - static DISABLE_UNICODE_GROUPS = 8 + static DISABLE_UNICODE_GROUPS = 8; /** * Returns a literal pattern string for the specified string. @@ -46,7 +46,7 @@ class RE2JS { * @returns {string} A literal string replacement */ static quote(str: string): string { - return Utils.quoteMeta(str) + return Utils.quoteMeta(str); } /** @@ -56,16 +56,10 @@ class RE2JS { * @returns {RE2JS} */ static compile(regex: string, flags = 0): RE2JS { - let fregex = regex - if ((flags & RE2JS.CASE_INSENSITIVE) !== 0) { - fregex = `(?i)${fregex}` - } - if ((flags & RE2JS.DOTALL) !== 0) { - fregex = `(?s)${fregex}` - } - if ((flags & RE2JS.MULTILINE) !== 0) { - fregex = `(?m)${fregex}` - } + return new RE2JS(regex, flags); + } + + static validateFlags(flags: number): void { if ( (flags & ~( @@ -77,18 +71,23 @@ class RE2JS { 0 ) { throw new RE2JSFlagsException( - 'Flags should only be a combination of MULTILINE, DOTALL, CASE_INSENSITIVE, DISABLE_UNICODE_GROUPS' - ) + "Flags should only be a combination of MULTILINE, DOTALL, CASE_INSENSITIVE, DISABLE_UNICODE_GROUPS", + ); } + } - let re2Flags = RE2Flags.PERL - if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) { - re2Flags &= ~RE2Flags.UNICODE_GROUPS + static buildRegexWithFlags(regex: string, flags = 0): string { + let fregex = regex; + if ((flags & RE2JS.CASE_INSENSITIVE) !== 0) { + fregex = `(?i)${fregex}`; } - - const p = new RE2JS(regex, flags) - p.re2Input = RE2.compileImpl(fregex, re2Flags) - return p + if ((flags & RE2JS.DOTALL) !== 0) { + fregex = `(?s)${fregex}`; + } + if ((flags & RE2JS.MULTILINE) !== 0) { + fregex = `(?m)${fregex}`; + } + return fregex; } /** @@ -100,39 +99,31 @@ class RE2JS { * @throws RE2JSSyntaxException if the regular expression is malformed */ static matches(regex: string, input: string): boolean { - return RE2JS.compile(regex).testExact(input) - } - - /** - * This is visible for testing. - * @private - */ - static initTest(pattern: string, flags: number, re2: any): RE2JS { - if (pattern == null) { - throw new Error('pattern is null') - } - if (re2 == null) { - throw new Error('re2 is null') - } - const p = new RE2JS(pattern, flags) - p.re2Input = re2 - return p + return RE2JS.compile(regex).testExact(input); } /** * @param {string} pattern * @param {number} flags */ - constructor(pattern: string, flags: number) { - this.patternInput = pattern - this.flagsInput = flags + constructor(pattern: string, flags = 0) { + let re2Flags = RE2Flags.PERL; + if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) { + re2Flags &= ~RE2Flags.UNICODE_GROUPS; + } + RE2JS.validateFlags(flags); + const fregex = RE2JS.buildRegexWithFlags(pattern, flags); + + this.patternInput = pattern; + this.flagsInput = flags; + this.re2Input = RE2.compileImpl(fregex, re2Flags); } /** * Releases memory used by internal caches associated with this pattern. */ reset(): void { - this.re2Input.reset() + this.re2Input.reset(); } /** @@ -140,7 +131,7 @@ class RE2JS { * @returns {number} */ flags(): number { - return this.flagsInput + return this.flagsInput; } /** @@ -148,11 +139,11 @@ class RE2JS { * @returns {string} */ pattern(): string { - return this.patternInput + return this.patternInput; } - re2(): any { - return this.re2Input + re2(): RE2 { + return this.re2Input; } /** @@ -162,7 +153,7 @@ class RE2JS { * @returns {boolean} true if the regular expression matches the entire input */ matches(input: string): boolean { - return this.testExact(input) + return this.testExact(input); } /** @@ -172,7 +163,7 @@ class RE2JS { * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise. */ test(input: string): boolean { - return this.re2Input.match(input) + return this.re2Input.match(input); } /** @@ -183,16 +174,20 @@ class RE2JS { */ testExact(input: string): boolean { return ( - this.re2Input.executeEngine(MachineInput.fromUTF16(input), 0, RE2Flags.ANCHOR_BOTH, 0) !== - null - ) + this.re2Input.executeEngine( + fromUTF16(input), + 0, + RE2Flags.ANCHOR_BOTH, + 0, + ) !== null + ); } /** * @returns {string} */ toString(): string { - return this.patternInput + return this.patternInput; } /** @@ -200,15 +195,15 @@ class RE2JS { * @returns {number} */ groupCount(): number { - return this.re2Input.numberOfCapturingGroups() + return this.re2Input.numberOfCapturingGroups(); } /** * Return a map of the capturing groups in this matcher's pattern. - * @returns {Record} + * @returns {Map} */ - namedGroups(): Record { - return this.re2Input.namedGroups + namedGroups(): Map { + return this.re2Input.namedGroups; } } @@ -220,4 +215,4 @@ export { RE2JSGroupException, RE2JSFlagsException, RE2JSInternalException, -} +}; diff --git a/packages/re2/tsconfig.json b/packages/re2/tsconfig.json index db5192c..be51485 100644 --- a/packages/re2/tsconfig.json +++ b/packages/re2/tsconfig.json @@ -2,9 +2,5 @@ "files": ["src/index.ts"], "extends": "../../tsconfig.base.json", "include": ["src/**/*.test.ts"], - "exclude": [ - "./src/__tests__", - "./src/__fixtures__", - "./src/__utils__" - ] + "exclude": ["./src/__tests__", "./src/__fixtures__", "./src/__utils__"] } From 0eac393745711fe0d697200630b6d92ba6404273 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Mon, 20 Apr 2026 14:44:21 -0400 Subject: [PATCH 06/13] additional lint updates --- packages/re2/src/CharClass.ts | 40 +- packages/re2/src/Compiler.ts | 51 +- packages/re2/src/DFA.ts | 130 +---- packages/re2/src/Inst.ts | 8 +- packages/re2/src/MachineInput.ts | 36 +- packages/re2/src/Parser.ts | 118 +++-- packages/re2/src/Prefilter.ts | 4 +- packages/re2/src/Prog.ts | 4 +- packages/re2/src/RE2.ts | 34 +- packages/re2/src/RE2Flags.ts | 102 ++-- packages/re2/src/Simplify.ts | 453 +++++++++--------- packages/re2/src/Unicode.ts | 283 +++++------ packages/re2/src/Utils.ts | 217 +++++---- packages/re2/src/__tests__/BugHunt.test.ts | 20 +- packages/re2/src/__tests__/CharClass.test.ts | 48 +- packages/re2/src/__tests__/DFA.test.ts | 24 +- packages/re2/src/__tests__/Exec.test.ts | 10 +- packages/re2/src/__tests__/Inst.test.ts | 4 +- packages/re2/src/__tests__/Parser.test.ts | 57 +-- packages/re2/src/__tests__/Prefilter.test.ts | 33 +- .../src/__tests__/RE2ExecuteEngine.test.ts | 8 +- .../re2/src/__tests__/RE2QuoteMeta.test.ts | 6 +- packages/re2/src/__tests__/Unicode.test.ts | 8 +- packages/re2/src/__tests__/edge-cases.test.ts | 55 +-- packages/re2/src/__utils__/parser.ts | 16 +- packages/re2/src/index.ts | 17 +- 26 files changed, 855 insertions(+), 931 deletions(-) diff --git a/packages/re2/src/CharClass.ts b/packages/re2/src/CharClass.ts index 8a10058..27f9294 100644 --- a/packages/re2/src/CharClass.ts +++ b/packages/re2/src/CharClass.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from "./RE2Flags.js"; -import { Unicode } from "./Unicode.js"; -import { Utils } from "./Utils.js"; +import { FOLD_CASE } from "./RE2Flags.js"; +import { MAX_FOLD, MAX_RUNE, MIN_FOLD, simpleFold } from "./Unicode.js"; +import { emptyInts } from "./Utils.js"; /** * A "builder"-style helper class for manipulating character classes represented as an array of * pairs of runes [lo, hi], each denoting an inclusive interval. @@ -63,7 +63,7 @@ class CharClass { r: number[]; len: number; - constructor(r = Utils.emptyInts()) { + constructor(r = emptyInts()) { this.r = r; // inclusive ranges, pairs of [lo,hi]. r.length is even. this.len = r.length; // prefix of |r| that is defined. Even. } @@ -111,7 +111,7 @@ class CharClass { // appendLiteral() appends the literal |x| to this CharClass. appendLiteral(x: number, flags: number): this { - return (flags & RE2Flags.FOLD_CASE) !== 0 + return (flags & FOLD_CASE) !== 0 ? this.appendFoldedRange(x, x) : this.appendRange(x, x); } @@ -150,30 +150,30 @@ class CharClass { // folding-equivalent runes to this CharClass. appendFoldedRange(lo: number, hi: number): this { // Optimizations. - if (lo <= Unicode.MIN_FOLD && hi >= Unicode.MAX_FOLD) { + if (lo <= MIN_FOLD && hi >= MAX_FOLD) { // Range is full: folding can't add more. return this.appendRange(lo, hi); } - if (hi < Unicode.MIN_FOLD || lo > Unicode.MAX_FOLD) { + if (hi < MIN_FOLD || lo > MAX_FOLD) { // Range is outside folding possibilities. return this.appendRange(lo, hi); } - if (lo < Unicode.MIN_FOLD) { + if (lo < MIN_FOLD) { // [lo, minFold-1] needs no folding. - this.appendRange(lo, Unicode.MIN_FOLD - 1); - lo = Unicode.MIN_FOLD; + this.appendRange(lo, MIN_FOLD - 1); + lo = MIN_FOLD; } - if (hi > Unicode.MAX_FOLD) { + if (hi > MAX_FOLD) { // [maxFold+1, hi] needs no folding. - this.appendRange(Unicode.MAX_FOLD + 1, hi); - hi = Unicode.MAX_FOLD; + this.appendRange(MAX_FOLD + 1, hi); + hi = MAX_FOLD; } // Brute force. Depend on appendRange to coalesce ranges on the fly. for (let c = lo; c <= hi; c++) { this.appendRange(c, c); - for (let f = Unicode.simpleFold(c); f !== c; f = Unicode.simpleFold(f)) { + for (let f = simpleFold(c); f !== c; f = simpleFold(f)) { this.appendRange(f, f); } } @@ -210,8 +210,8 @@ class CharClass { } nextLo = hi + 1; } - if (nextLo <= Unicode.MAX_RUNE) { - this.appendRange(nextLo, Unicode.MAX_RUNE); + if (nextLo <= MAX_RUNE) { + this.appendRange(nextLo, MAX_RUNE); } return this; } @@ -256,8 +256,8 @@ class CharClass { nextLo = c + 1; } } - if (nextLo <= Unicode.MAX_RUNE) { - this.appendRange(nextLo, Unicode.MAX_RUNE); + if (nextLo <= MAX_RUNE) { + this.appendRange(nextLo, MAX_RUNE); } return this; } @@ -283,9 +283,9 @@ class CharClass { nextLo = hi + 1; } this.len = w; - if (nextLo <= Unicode.MAX_RUNE) { + if (nextLo <= MAX_RUNE) { this.r[this.len++] = nextLo; - this.r[this.len++] = Unicode.MAX_RUNE; + this.r[this.len++] = MAX_RUNE; } return this; } diff --git a/packages/re2/src/Compiler.ts b/packages/re2/src/Compiler.ts index 723b5cf..60f66bd 100644 --- a/packages/re2/src/Compiler.ts +++ b/packages/re2/src/Compiler.ts @@ -1,6 +1,13 @@ -import { RE2Flags } from "./RE2Flags.js"; -import { Unicode } from "./Unicode.js"; -import { Utils } from "./Utils.js"; +import { NON_GREEDY, FOLD_CASE } from "./RE2Flags.js"; +import { MAX_RUNE, simpleFold } from "./Unicode.js"; +import { + EMPTY_BEGIN_TEXT, + EMPTY_END_TEXT, + EMPTY_BEGIN_LINE, + EMPTY_WORD_BOUNDARY, + EMPTY_END_LINE, + EMPTY_NO_WORD_BOUNDARY, +} from "./Utils.js"; import { Regexp } from "./Regexp.js"; import { Inst } from "./Inst.js"; import { Prog, PatchList } from "./Prog.js"; @@ -33,11 +40,11 @@ class Compiler { prog: Prog; static ANY_RUNE_NOT_NL(): number[] { - return [0, 0x0a - 1, 0x0a + 1, Unicode.MAX_RUNE]; + return [0, 0x0a - 1, 0x0a + 1, MAX_RUNE]; } static ANY_RUNE(): number[] { - return [0, Unicode.MAX_RUNE]; + return [0, MAX_RUNE]; } static compileRegexp(re: Regexp): Prog { @@ -202,29 +209,25 @@ class Compiler { f.nullable = false; const i = this.prog.getInst(f.i); i.runes = runes; - flags &= RE2Flags.FOLD_CASE; - if (runes.length !== 1 || Unicode.simpleFold(runes[0]) === runes[0]) { - flags &= ~RE2Flags.FOLD_CASE; + flags &= FOLD_CASE; + if (runes.length !== 1 || simpleFold(runes[0]) === runes[0]) { + flags &= ~FOLD_CASE; } i.arg = flags; f.out = new PatchList(f.i << 1, f.i << 1); if ( - ((flags & RE2Flags.FOLD_CASE) === 0 && runes.length === 1) || + ((flags & FOLD_CASE) === 0 && runes.length === 1) || (runes.length === 2 && runes[0] === runes[1]) ) { i.op = Inst.RUNE1; - } else if ( - runes.length === 2 && - runes[0] === 0 && - runes[1] === Unicode.MAX_RUNE - ) { + } else if (runes.length === 2 && runes[0] === 0 && runes[1] === MAX_RUNE) { i.op = Inst.RUNE_ANY; } else if ( runes.length === 4 && runes[0] === 0 && runes[1] === 0x0a - 1 && runes[2] === 0x0a + 1 && - runes[3] === Unicode.MAX_RUNE + runes[3] === MAX_RUNE ) { i.op = Inst.RUNE_ANY_NOT_NL; } @@ -255,17 +258,17 @@ class Compiler { case Regexp.Op.ANY_CHAR: return this.rune(Compiler.ANY_RUNE(), 0); case Regexp.Op.BEGIN_LINE: - return this.empty(Utils.EMPTY_BEGIN_LINE); + return this.empty(EMPTY_BEGIN_LINE); case Regexp.Op.END_LINE: - return this.empty(Utils.EMPTY_END_LINE); + return this.empty(EMPTY_END_LINE); case Regexp.Op.BEGIN_TEXT: - return this.empty(Utils.EMPTY_BEGIN_TEXT); + return this.empty(EMPTY_BEGIN_TEXT); case Regexp.Op.END_TEXT: - return this.empty(Utils.EMPTY_END_TEXT); + return this.empty(EMPTY_END_TEXT); case Regexp.Op.WORD_BOUNDARY: - return this.empty(Utils.EMPTY_WORD_BOUNDARY); + return this.empty(EMPTY_WORD_BOUNDARY); case Regexp.Op.NO_WORD_BOUNDARY: - return this.empty(Utils.EMPTY_NO_WORD_BOUNDARY); + return this.empty(EMPTY_NO_WORD_BOUNDARY); case Regexp.Op.CAPTURE: { const bra = this.cap(re.cap << 1); const sub = this.compile(re.subs[0]); @@ -275,17 +278,17 @@ class Compiler { case Regexp.Op.STAR: return this.star( this.compile(re.subs[0]), - (re.flags & RE2Flags.NON_GREEDY) !== 0, + (re.flags & NON_GREEDY) !== 0, ); case Regexp.Op.PLUS: return this.plus( this.compile(re.subs[0]), - (re.flags & RE2Flags.NON_GREEDY) !== 0, + (re.flags & NON_GREEDY) !== 0, ); case Regexp.Op.QUEST: return this.quest( this.compile(re.subs[0]), - (re.flags & RE2Flags.NON_GREEDY) !== 0, + (re.flags & NON_GREEDY) !== 0, ); case Regexp.Op.CONCAT: { if (re.subs.length === 0) { diff --git a/packages/re2/src/DFA.ts b/packages/re2/src/DFA.ts index 951fba0..bd1d38d 100644 --- a/packages/re2/src/DFA.ts +++ b/packages/re2/src/DFA.ts @@ -1,7 +1,7 @@ import { Inst } from "./Inst.js"; -import { RE2Flags } from "./RE2Flags.js"; -import { Unicode } from "./Unicode.js"; -import { Utils } from "./Utils.js"; +import { UNANCHORED, ANCHOR_BOTH } from "./RE2Flags.js"; +import { MAX_ASCII, MAX_RUNE } from "./Unicode.js"; +import { emptyOpContext } from "./Utils.js"; import type { Prog } from "./Prog.js"; // FNV-1a 32-bit hash for an array of integers. @@ -27,7 +27,7 @@ class DFAState { isMatch: boolean; hasEmptyWidth: boolean; matchIDs: number[]; - nextAscii: any[]; + nextAscii: (DFAState | null)[]; nextMap: Map; constructor( @@ -40,7 +40,7 @@ class DFAState { this.isMatch = isMatch; this.hasEmptyWidth = hasEmptyWidth; // true if any PC is an EMPTY_WIDTH instruction this.matchIDs = matchIDs; - this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null); + this.nextAscii = new Array(MAX_ASCII + 1).fill(null); this.nextMap = new Map(); } } @@ -233,23 +233,19 @@ class DFA { if (state.hasEmptyWidth) { // Context-dependent: include context in key cacheKey = - charCode * 128 + - (context & 0x3f) * 2 + - (anchor === RE2Flags.UNANCHORED ? 0 : 1); + charCode * 128 + (context & 0x3f) * 2 + (anchor === UNANCHORED ? 0 : 1); if (state.nextMap.has(cacheKey)) { return state.nextMap.get(cacheKey); } } else { // Context-independent: use original caching - if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) { + if (anchor === UNANCHORED && charCode <= MAX_ASCII) { const next = state.nextAscii[charCode]; if (next !== null) { return next; } } else { - cacheKey = - charCode + - (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1); + cacheKey = charCode + (anchor === UNANCHORED ? 0 : MAX_RUNE + 1); if (state.nextMap.has(cacheKey)) { return state.nextMap.get(cacheKey); } @@ -257,7 +253,7 @@ class DFA { } // Determine which PCs to check for RUNE matches - let activePCs; + let activePCs: Set | Int32Array; if (state.hasEmptyWidth) { const { resolvedPCs } = this.resolveEmptyWidth(state.nfaStates, context); activePCs = resolvedPCs; @@ -275,7 +271,7 @@ class DFA { } } - if (anchor === RE2Flags.UNANCHORED) { + if (anchor === UNANCHORED) { nextPCs.push(this.prog.start); } @@ -284,30 +280,16 @@ class DFA { // Cache the result if (state.hasEmptyWidth) { state.nextMap.set(cacheKey, nextState); - } else if ( - anchor === RE2Flags.UNANCHORED && - charCode <= Unicode.MAX_ASCII - ) { + } else if (anchor === UNANCHORED && charCode <= MAX_ASCII) { state.nextAscii[charCode] = nextState; } else { - cacheKey = - charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1); + cacheKey = charCode + (anchor === UNANCHORED ? 0 : MAX_RUNE + 1); state.nextMap.set(cacheKey, nextState); } return nextState; } - // Check if a state matches after resolving EMPTY_WIDTH with end-of-input context - checkEndMatch(state: DFAState, prevRune: number): boolean { - if (state.isMatch) return true; - if (!state.hasEmptyWidth) return false; - - const endContext = Utils.emptyOpContext(prevRune, -1); - const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endContext); - return isMatch; - } - // The hot loop: Execute the Lazy DFA match(input: any, pos: number, anchor: number): boolean | null { if (!this.startState) { @@ -329,7 +311,7 @@ class DFA { // Check if start state matches directly (e.g., empty pattern) if (currentState.isMatch) { - if (anchor === RE2Flags.ANCHOR_BOTH) { + if (anchor === ANCHOR_BOTH) { if (pos === endPos) return true; } else { return true; @@ -345,7 +327,7 @@ class DFA { if (width === 0) break; // Compute context at position i (between prevRune and rune) - const context = Utils.emptyOpContext(prevRune, rune); + const context = emptyOpContext(prevRune, rune); // Before consuming: check if EMPTY_WIDTH in current state resolves to MATCH if (currentState.hasEmptyWidth) { @@ -354,7 +336,7 @@ class DFA { context, ); if (isMatch) { - if (anchor === RE2Flags.ANCHOR_BOTH) { + if (anchor === ANCHOR_BOTH) { // Match at position i (before consuming rune) — only valid if i === endPos // which can't happen in this loop, so skip } else { @@ -366,8 +348,8 @@ class DFA { // Consume rune and transition to next state if ( !currentState.hasEmptyWidth && - anchor === RE2Flags.UNANCHORED && - rune <= Unicode.MAX_ASCII + anchor === UNANCHORED && + rune <= MAX_ASCII ) { currentState = currentState.nextAscii[rune] || @@ -380,7 +362,7 @@ class DFA { // After consuming: check if new state is a match if (currentState.isMatch) { - if (anchor === RE2Flags.ANCHOR_BOTH) { + if (anchor === ANCHOR_BOTH) { if (i + width === endPos) return true; } else { return true; @@ -388,7 +370,7 @@ class DFA { } if (currentState.nfaStates.length === 0) { - if (anchor !== RE2Flags.UNANCHORED) return false; + if (anchor !== UNANCHORED) return false; } prevRune = rune; @@ -400,7 +382,7 @@ class DFA { // UNANCHORED/ANCHOR_START accept any match; ANCHOR_BOTH accepts it because // we have consumed the entire input up to endPos. if (currentState.hasEmptyWidth) { - const endContext = Utils.emptyOpContext(prevRune, -1); + const endContext = emptyOpContext(prevRune, -1); const { isMatch } = this.resolveEmptyWidth( currentState.nfaStates, endContext, @@ -410,78 +392,6 @@ class DFA { return false; } - - // Multi-Pattern Set matching (kept for compatibility) - matchSet(input: any, pos: number, anchor: number): number[] | null { - if ( - (anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && - pos !== 0 - ) { - return []; - } - - if (!this.startState) { - this.startState = this.getState([this.prog.start]); - if (!this.startState) return null; - } - - let endPos = input.endPos(); - let currentState: DFAState | null = this.startState; - let prevRune = -1; - const matches = new Set(); - - const checkMatch = ( - state: DFAState, - currentPos: number, - prevR: number, - ): void => { - if (state.isMatch) { - if (anchor === RE2Flags.ANCHOR_BOTH) { - if (currentPos === endPos) { - state.matchIDs.forEach((id: number) => matches.add(id)); - } - } else { - state.matchIDs.forEach((id: number) => matches.add(id)); - } - } - // Also check EMPTY_WIDTH resolution at end - if (state.hasEmptyWidth && currentPos === endPos) { - const endCtx = Utils.emptyOpContext(prevR, -1); - const { isMatch } = this.resolveEmptyWidth(state.nfaStates, endCtx); - if (isMatch) { - if (anchor === RE2Flags.ANCHOR_BOTH) { - state.matchIDs.forEach((id: number) => matches.add(id)); - } - } - } - }; - - checkMatch(currentState, pos, prevRune); - - let i = pos; - while (i < endPos) { - const r = input.step(i); - const rune = r >> 3; - const width = r & 7; - - if (width === 0) break; - - const context = Utils.emptyOpContext(prevRune, rune); - currentState = this.step(currentState, rune, anchor, context); - - if (currentState === null) return null; - - prevRune = rune; - i += width; - checkMatch(currentState, i, prevRune); - - if (currentState.nfaStates.length === 0) { - if (anchor !== RE2Flags.UNANCHORED) break; - } - } - - return Array.from(matches).sort((a, b) => a - b); - } } export { DFA }; diff --git a/packages/re2/src/Inst.ts b/packages/re2/src/Inst.ts index 321f16a..23c194f 100644 --- a/packages/re2/src/Inst.ts +++ b/packages/re2/src/Inst.ts @@ -1,5 +1,5 @@ -import { RE2Flags } from "./RE2Flags.js"; -import { Unicode } from "./Unicode.js"; +import { FOLD_CASE } from "./RE2Flags.js"; +import { equalsIgnoreCase } from "./Unicode.js"; /** * A single instruction in the regular expression virtual machine. * @@ -47,8 +47,8 @@ class Inst { // Note that this may result in a case-folding loop when executed, // so attempt to reduce the chance of that occurring // by performing case folding on |r0| from the pattern rather than |r| from the input. - if ((this.arg & RE2Flags.FOLD_CASE) !== 0) { - return Unicode.equalsIgnoreCase(r0, r); + if ((this.arg & FOLD_CASE) !== 0) { + return equalsIgnoreCase(r0, r); } return r === r0; } diff --git a/packages/re2/src/MachineInput.ts b/packages/re2/src/MachineInput.ts index e8c7deb..a4536cf 100644 --- a/packages/re2/src/MachineInput.ts +++ b/packages/re2/src/MachineInput.ts @@ -1,5 +1,11 @@ -import { Utils } from "./Utils.js"; -import { Unicode } from "./Unicode.js"; +import { emptyOpContext } from "./Utils.js"; +import { + MAX_HIGH_SURROGATE, + MAX_LOW_SURROGATE, + MIN_HIGH_SURROGATE, + MIN_LOW_SURROGATE, + MIN_SUPPLEMENTARY_CODE_POINT, +} from "./Unicode.js"; import type { Prefilter } from "./Prefilter.js"; import type { RE2 } from "./RE2.js"; @@ -37,8 +43,8 @@ class MachineUTF16Input { // Fast path: standard BMP character (not a high surrogate) if ( - c1 < Unicode.MIN_HIGH_SURROGATE || - c1 > Unicode.MAX_HIGH_SURROGATE || + c1 < MIN_HIGH_SURROGATE || + c1 > MAX_HIGH_SURROGATE || pos + 1 >= this.end ) { return (c1 << 3) | 1; @@ -46,11 +52,11 @@ class MachineUTF16Input { // Slow path: Calculate surrogate pair manually const c2 = this.charSequence.charCodeAt(pos + 1); - if (c2 >= Unicode.MIN_LOW_SURROGATE && c2 <= Unicode.MAX_LOW_SURROGATE) { + if (c2 >= MIN_LOW_SURROGATE && c2 <= MAX_LOW_SURROGATE) { const rune = - (c1 - Unicode.MIN_HIGH_SURROGATE) * 0x400 + - (c2 - Unicode.MIN_LOW_SURROGATE) + - Unicode.MIN_SUPPLEMENTARY_CODE_POINT; + (c1 - MIN_HIGH_SURROGATE) * 0x400 + + (c2 - MIN_LOW_SURROGATE) + + MIN_SUPPLEMENTARY_CODE_POINT; return (rune << 3) | 2; } @@ -66,13 +72,17 @@ class MachineUTF16Input { context(pos: number): number { pos += this.start; - const r1 = + const r1: number | undefined = pos > 0 && pos <= this.charSequence.length - ? this.charSequence.codePointAt(pos - 1)! + ? this.charSequence.codePointAt(pos - 1) : -1; - const r2 = - pos < this.charSequence.length ? this.charSequence.codePointAt(pos)! : -1; - return Utils.emptyOpContext(r1, r2); + const r2: number | undefined = + pos < this.charSequence.length ? this.charSequence.codePointAt(pos) : -1; + + if (r1 === undefined || r2 === undefined) { + throw new Error("invalid state"); + } + return emptyOpContext(r1, r2); } prefixLength(re2: RE2): number { diff --git a/packages/re2/src/Parser.ts b/packages/re2/src/Parser.ts index 82d3998..5f2ffe8 100644 --- a/packages/re2/src/Parser.ts +++ b/packages/re2/src/Parser.ts @@ -1,9 +1,31 @@ -import { RE2Flags } from "./RE2Flags.js"; -import { Unicode } from "./Unicode.js"; +import { + CLASS_NL, + DOT_NL, + FOLD_CASE, + LITERAL, + NON_GREEDY, + ONE_LINE, + UNICODE_GROUPS, + WAS_DOLLAR, +} from "./RE2Flags.js"; +import { + MAX_ASCII, + MAX_BMP, + MAX_FOLD, + MAX_RUNE, + MIN_FOLD, + simpleFold, +} from "./Unicode.js"; import { UnicodeTables } from "./UnicodeTables.js"; import { UnicodeRangeTable } from "./UnicodeRangeTable.js"; import { getPerlGroups, getPosixGroups } from "./CharGroup.js"; -import { Utils } from "./Utils.js"; +import { + unhex, + isalnum, + charCount, + stringToRunes, + runeToString, +} from "./Utils.js"; import { CharClass } from "./CharClass.js"; import { RE2JSSyntaxException } from "./exceptions.js"; import { Regexp } from "./Regexp.js"; @@ -68,7 +90,7 @@ class StringIterator { // past it. Precondition: |more()|. pop(): number { const r = this.str.codePointAt(this.position)!; - this.position += Utils.charCount(r); + this.position += charCount(r); return r; } @@ -91,6 +113,7 @@ class StringIterator { return this.rest(); } } + /** * A parser of regular expression patterns. * @@ -159,9 +182,7 @@ class Parser { // RangeTables are represented as int[][], a list of triples (start, end, // stride). - static ANY_TABLE = new UnicodeRangeTable( - new Uint32Array([0, Unicode.MAX_RUNE, 1]), - ); + static ANY_TABLE = new UnicodeRangeTable(new Uint32Array([0, MAX_RUNE, 1])); // Ascii tables static ASCII_TABLE = new UnicodeRangeTable(new Uint32Array([0, 0x7f, 1])); @@ -229,13 +250,13 @@ class Parser { // minFoldRune returns the minimum rune fold-equivalent to r. static minFoldRune(r: number): number { - if (r < Unicode.MIN_FOLD || r > Unicode.MAX_FOLD) { + if (r < MIN_FOLD || r > MAX_FOLD) { return r; } let min = r; const r0 = r; - for (r = Unicode.simpleFold(r); r !== r0; r = Unicode.simpleFold(r)) { + for (r = simpleFold(r); r !== r0; r = simpleFold(r)) { if (min > r) { min = r; } @@ -246,9 +267,10 @@ class Parser { static literalRegexp(s: string, flags: number): Regexp { const re = new Regexp(Regexp.Op.LITERAL); re.flags = flags; - re.runes = Utils.stringToRunes(s) as number[]; + re.runes = stringToRunes(s) as number[]; return re; } + /** * Parse regular expression pattern {@code pattern} with mode flags {@code flags}. * @param {string} pattern @@ -315,7 +337,7 @@ class Parser { ); } - return (min << 16) | (max & Unicode.MAX_BMP); + return (min << 16) | (max & MAX_BMP); } // isValidCaptureName reports whether name @@ -330,7 +352,7 @@ class Parser { for (let i = 0; i < name.length; i++) { const c = name.codePointAt(i)!; - if (c !== 0x5f && !Utils.isalnum(c)) { + if (c !== 0x5f && !isalnum(c)) { return false; } } @@ -470,12 +492,12 @@ class Parser { if (c === 0x7d) { break; } - const v = Utils.unhex(c); + const v = unhex(c); if (v < 0) { break bigswitch; } r = r * 16 + v; - if (r > Unicode.MAX_RUNE) { + if (r > MAX_RUNE) { break bigswitch; } nhex++; @@ -485,12 +507,12 @@ class Parser { } return r; } - const x = Utils.unhex(c); + const x = unhex(c); if (!t.more()) { break; } c = t.pop(); - const y = Utils.unhex(c); + const y = unhex(c); if (x < 0 || y < 0) { break; } @@ -509,7 +531,7 @@ class Parser { case 0x76: return 0x0b; default: - if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) { + if (c <= MAX_ASCII && !isalnum(c)) { return c; } break; @@ -760,33 +782,33 @@ class Parser { re.runes.length === 2 && re.runes[0] === re.runes[1] ) { - if (this.maybeConcat(re.runes[0], this.flags & ~RE2Flags.FOLD_CASE)) { + if (this.maybeConcat(re.runes[0], this.flags & ~FOLD_CASE)) { return null; } re.op = Regexp.Op.LITERAL; re.runes = [re.runes[0]]; - re.flags = this.flags & ~RE2Flags.FOLD_CASE; + re.flags = this.flags & ~FOLD_CASE; } else if ( (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 4 && re.runes[0] === re.runes[1] && re.runes[2] === re.runes[3] && - Unicode.simpleFold(re.runes[0]) === re.runes[2] && - Unicode.simpleFold(re.runes[2]) === re.runes[0]) || + simpleFold(re.runes[0]) === re.runes[2] && + simpleFold(re.runes[2]) === re.runes[0]) || (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 2 && re.runes[0] + 1 === re.runes[1] && - Unicode.simpleFold(re.runes[0]) === re.runes[1] && - Unicode.simpleFold(re.runes[1]) === re.runes[0]) + simpleFold(re.runes[0]) === re.runes[1] && + simpleFold(re.runes[1]) === re.runes[0]) ) { // Case-insensitive rune like [Aa] or [Δδ]. - if (this.maybeConcat(re.runes[0], this.flags | RE2Flags.FOLD_CASE)) { + if (this.maybeConcat(re.runes[0], this.flags | FOLD_CASE)) { return null; } // Rewrite as (case-insensitive) literal. re.op = Regexp.Op.LITERAL; re.runes = [re.runes[0]]; - re.flags = this.flags | RE2Flags.FOLD_CASE; + re.flags = this.flags | FOLD_CASE; } else { // Incremental concatenation. this.maybeConcat(-1, 0); @@ -815,7 +837,7 @@ class Parser { if ( re1.op !== Regexp.Op.LITERAL || re2.op !== Regexp.Op.LITERAL || - (re1.flags & RE2Flags.FOLD_CASE) !== (re2.flags & RE2Flags.FOLD_CASE) + (re1.flags & FOLD_CASE) !== (re2.flags & FOLD_CASE) ) { return false; } @@ -836,7 +858,7 @@ class Parser { newLiteral(r: number, flags: number): Regexp { const re = this.newRegexp(Regexp.Op.LITERAL); re.flags = flags; - if ((flags & RE2Flags.FOLD_CASE) !== 0) { + if ((flags & FOLD_CASE) !== 0) { r = Parser.minFoldRune(r); } re.runes = [r]; @@ -873,7 +895,7 @@ class Parser { let flags = this.flags; if (t.more() && t.lookingAt("?")) { t.skip(1); - flags ^= RE2Flags.NON_GREEDY; + flags ^= NON_GREEDY; } if (lastRepeatPos !== -1) { throw new RE2JSSyntaxException( @@ -991,7 +1013,7 @@ class Parser { if ( re.runes.length === 2 && re.runes[0] === 0 && - re.runes[1] === Unicode.MAX_RUNE + re.runes[1] === MAX_RUNE ) { re.runes = []; re.op = Regexp.Op.ANY_CHAR; @@ -1000,7 +1022,7 @@ class Parser { re.runes[0] === 0 && re.runes[1] === 0x0a - 1 && re.runes[2] === 0x0a + 1 && - re.runes[3] === Unicode.MAX_RUNE + re.runes[3] === MAX_RUNE ) { re.runes = []; re.op = Regexp.Op.ANY_CHAR_NOT_NL; @@ -1048,7 +1070,7 @@ class Parser { } parseInternal(): Regexp { - if ((this.flags & RE2Flags.LITERAL) !== 0) { + if ((this.flags & LITERAL) !== 0) { // Trivial parser for literal string. return Parser.literalRegexp(this.wholeRegexp, this.flags); } @@ -1079,7 +1101,7 @@ class Parser { t.skip(1); // ')' break; case 0x5e: - if ((this.flags & RE2Flags.ONE_LINE) !== 0) { + if ((this.flags & ONE_LINE) !== 0) { this.op(Regexp.Op.BEGIN_TEXT); } else { this.op(Regexp.Op.BEGIN_LINE); @@ -1087,15 +1109,15 @@ class Parser { t.skip(1); // '^' break; case 0x24: - if ((this.flags & RE2Flags.ONE_LINE) !== 0) { - this.op(Regexp.Op.END_TEXT)!.flags |= RE2Flags.WAS_DOLLAR; + if ((this.flags & ONE_LINE) !== 0) { + this.op(Regexp.Op.END_TEXT)!.flags |= WAS_DOLLAR; } else { this.op(Regexp.Op.END_LINE); } t.skip(1); // '$' break; case 0x2e: - if ((this.flags & RE2Flags.DOT_NL) !== 0) { + if ((this.flags & DOT_NL) !== 0) { this.op(Regexp.Op.ANY_CHAR); } else { this.op(Regexp.Op.ANY_CHAR_NOT_NL); @@ -1136,7 +1158,7 @@ class Parser { break; } min = minMax >> 16; - max = ((minMax & Unicode.MAX_BMP) << 16) >> 16; + max = ((minMax & MAX_BMP) << 16) >> 16; this.repeat( Regexp.Op.REPEAT, min, @@ -1185,7 +1207,7 @@ class Parser { while (j < lit.length) { const codepoint = lit.codePointAt(j)!; this.literal(codepoint); - j += Utils.charCount(codepoint); + j += charCount(codepoint); } break bigswitch; } @@ -1312,19 +1334,19 @@ class Parser { const c = t.pop(); switch (c) { case 0x69: - flags |= RE2Flags.FOLD_CASE; + flags |= FOLD_CASE; sawFlag = true; break; case 0x6d: - flags &= ~RE2Flags.ONE_LINE; + flags &= ~ONE_LINE; sawFlag = true; break; case 0x73: - flags |= RE2Flags.DOT_NL; + flags |= DOT_NL; sawFlag = true; break; case 0x55: - flags |= RE2Flags.NON_GREEDY; + flags |= NON_GREEDY; sawFlag = true; break; // Switch to negation. @@ -1479,7 +1501,7 @@ class Parser { if (g === null) { return false; } - cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0); + cc.appendGroup(g, (this.flags & FOLD_CASE) !== 0); return true; } @@ -1504,7 +1526,7 @@ class Parser { if (g === null) { throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, name); } - cc.appendGroup(g, (this.flags & RE2Flags.FOLD_CASE) !== 0); + cc.appendGroup(g, (this.flags & FOLD_CASE) !== 0); return true; } @@ -1518,7 +1540,7 @@ class Parser { parseUnicodeClass(t: StringIterator, cc: CharClass): boolean { const startPos = t.pos(); if ( - (this.flags & RE2Flags.UNICODE_GROUPS) === 0 || + (this.flags & UNICODE_GROUPS) === 0 || (!t.lookingAt("\\p") && !t.lookingAt("\\P")) ) { return false; @@ -1541,7 +1563,7 @@ class Parser { if (c !== 0x7b) { // Single-letter name. - name = Utils.runeToString(c); + name = runeToString(c); } else { // Name is in braces. const rest = t.rest(); @@ -1577,7 +1599,7 @@ class Parser { const tab = pair.tab; const fold = pair.fold; // fold-equivalent table // Variation of CharClass.appendGroup() for tables. - if ((this.flags & RE2Flags.FOLD_CASE) === 0 || fold === null) { + if ((this.flags & FOLD_CASE) === 0 || fold === null) { cc.appendTableWithSign(tab, sign); } else { // Merge and clean tab and fold in a temporary buffer. @@ -1611,7 +1633,7 @@ class Parser { t.skip(1); // '^' // If character class does not match \n, add it here, // so that negation later will do the right thing. - if ((this.flags & RE2Flags.CLASS_NL) === 0) { + if ((this.flags & CLASS_NL) === 0) { cc.appendRange(0x0a, 0x0a); } } @@ -1657,7 +1679,7 @@ class Parser { } } } - if ((this.flags & RE2Flags.FOLD_CASE) === 0) { + if ((this.flags & FOLD_CASE) === 0) { cc.appendRange(lo, hi); } else { cc.appendFoldedRange(lo, hi); diff --git a/packages/re2/src/Prefilter.ts b/packages/re2/src/Prefilter.ts index f5b794f..a476010 100644 --- a/packages/re2/src/Prefilter.ts +++ b/packages/re2/src/Prefilter.ts @@ -1,6 +1,6 @@ import { Regexp } from "./Regexp.js"; -import { RE2Flags } from "./RE2Flags.js"; +import { FOLD_CASE } from "./RE2Flags.js"; import type { MachineUTF16Input } from "./MachineInput.js"; class Prefilter { @@ -63,7 +63,7 @@ class PrefilterTree { } case Regexp.Op.LITERAL: { - if (re.runes.length === 0 || (re.flags & RE2Flags.FOLD_CASE) !== 0) { + if (re.runes.length === 0 || (re.flags & FOLD_CASE) !== 0) { // Skip case-folded literals for simplicity return new Prefilter(Prefilter.Type.NONE); } diff --git a/packages/re2/src/Prog.ts b/packages/re2/src/Prog.ts index 2118e06..f623fed 100644 --- a/packages/re2/src/Prog.ts +++ b/packages/re2/src/Prog.ts @@ -1,4 +1,4 @@ -import { RE2Flags } from "./RE2Flags.js"; +import { FOLD_CASE } from "./RE2Flags.js"; import { Inst } from "./Inst.js"; /** @@ -85,7 +85,7 @@ class Prog { while ( Inst.isRuneOp(i.op) && i.runes.length === 1 && - (i.arg & RE2Flags.FOLD_CASE) === 0 + (i.arg & FOLD_CASE) === 0 ) { prefix += String.fromCodePoint(i.runes[0]); i = this.skipNop(i.out); diff --git a/packages/re2/src/RE2.ts b/packages/re2/src/RE2.ts index b16254f..130a8ca 100644 --- a/packages/re2/src/RE2.ts +++ b/packages/re2/src/RE2.ts @@ -1,12 +1,12 @@ -import { RE2Flags } from "./RE2Flags.js"; +import { ANCHOR_BOTH, ANCHOR_START, PERL, UNANCHORED } from "./RE2Flags.js"; import { fromUTF16, type MachineUTF16Input } from "./MachineInput.js"; import { DFA } from "./DFA.js"; import { Inst } from "./Inst.js"; import { Prefilter, PrefilterTree } from "./Prefilter.js"; import { Compiler } from "./Compiler.js"; -import { Simplify } from "./Simplify.js"; +import { simplify } from "./Simplify.js"; import { Parser } from "./Parser.js"; -import { Utils } from "./Utils.js"; +import { emptyOpContext } from "./Utils.js"; import type { Prog } from "./Prog.js"; class RE2 { @@ -22,7 +22,7 @@ class RE2 { namedGroups: Map; static compile(expr: string): RE2 { - return RE2.compileImpl(expr, RE2Flags.PERL); + return RE2.compileImpl(expr, PERL); } static compileImpl(expr: string, mode: number): RE2 { @@ -31,7 +31,7 @@ class RE2 { constructor(expr: string, mode: number) { let re = Parser.parse(expr, mode); - re = Simplify.simplify(re); + re = simplify(re); const prefilter = PrefilterTree.build(re); @@ -66,19 +66,19 @@ class RE2 { let matchEnd = -1; const pLen = input.prefixLength(this); - if (anchor === RE2Flags.UNANCHORED) { + if (anchor === UNANCHORED) { const idx = input.index(this, pos); if (idx < 0) return null; matchStart = pos + idx; matchEnd = matchStart + pLen; - } else if (anchor === RE2Flags.ANCHOR_BOTH) { + } else if (anchor === ANCHOR_BOTH) { // Match must span [pos, endPos] exactly and equal the prefix. if (input.endPos() - pos !== pLen) return null; const idx = input.index(this, pos); if (idx !== 0) return null; matchStart = pos; matchEnd = pos + pLen; - } else if (anchor === RE2Flags.ANCHOR_START) { + } else if (anchor === ANCHOR_START) { // Match must start at pos and equal the prefix. const idx = input.index(this, pos); if (idx !== 0) return null; @@ -107,7 +107,7 @@ class RE2 { return this.matchPrefixComplete(input, pos, anchor, ncap); } - if (this.prefilter !== null && anchor === RE2Flags.UNANCHORED) { + if (this.prefilter !== null && anchor === UNANCHORED) { if (!this.prefilter.eval(input, pos)) { return null; } @@ -170,10 +170,10 @@ class RE2 { for (let i = pos; i <= endPos; i++) { const rune = i < endPos ? input.step(i) >> 3 : -1; const width = i < endPos ? input.step(i) & 7 : 0; - const context = Utils.emptyOpContext(prevRune, rune); + const context = emptyOpContext(prevRune, rune); // Add start state at each position for unanchored search - if (anchor === RE2Flags.UNANCHORED || i === pos) { + if (anchor === UNANCHORED || i === pos) { const visited = new Set(); addState(current, visited, prog.start, context); } @@ -182,7 +182,7 @@ class RE2 { // For UNANCHORED/ANCHOR_START, a MATCH at any position succeeds. // For ANCHOR_BOTH, we must consume the entire input — intermediate // matches are skipped; only the final post-loop check accepts MATCH. - if (anchor !== RE2Flags.ANCHOR_BOTH) { + if (anchor !== ANCHOR_BOTH) { for (const pc of current) { const inst = prog.getInst(pc); if (inst.op === Inst.MATCH) { @@ -198,7 +198,7 @@ class RE2 { for (const pc of current) { const inst = prog.getInst(pc); if (Inst.isRuneOp(inst.op) && inst.matchRune(rune)) { - const nextContext = Utils.emptyOpContext( + const nextContext = emptyOpContext( rune, i + width < endPos ? input.step(i + width) >> 3 : -1, ); @@ -208,9 +208,9 @@ class RE2 { } // For unanchored, add start state at next position too - if (anchor === RE2Flags.UNANCHORED) { + if (anchor === UNANCHORED) { const nextRune = i + width < endPos ? input.step(i + width) >> 3 : -1; - const nextContext = Utils.emptyOpContext(rune, nextRune); + const nextContext = emptyOpContext(rune, nextRune); const visited = new Set(); addState(next, visited, prog.start, nextContext); } @@ -221,7 +221,7 @@ class RE2 { } // Final check for match after processing all input - const endContext = Utils.emptyOpContext(prevRune, -1); + const endContext = emptyOpContext(prevRune, -1); const visited = new Set(); const finalSet = new Set(); for (const pc of current) { @@ -248,7 +248,7 @@ class RE2 { } match(s: string): boolean { - return this.executeEngine(fromUTF16(s), 0, RE2Flags.UNANCHORED, 0) !== null; + return this.executeEngine(fromUTF16(s), 0, UNANCHORED, 0) !== null; } } diff --git a/packages/re2/src/RE2Flags.ts b/packages/re2/src/RE2Flags.ts index f71fe29..98d822f 100644 --- a/packages/re2/src/RE2Flags.ts +++ b/packages/re2/src/RE2Flags.ts @@ -1,49 +1,59 @@ //// Parser flags. -class RE2Flags { - // Fold case during matching (case-insensitive). - static FOLD_CASE = 0x01; - // Treat pattern as a literal string instead of a regexp. - static LITERAL = 0x02; - // Allow character classes like [^a-z] and [[:space:]] to match newline. - static CLASS_NL = 0x04; - // Allow '.' to match newline. - static DOT_NL = 0x08; - // Treat ^ and $ as only matching at beginning and end of text, not - // around embedded newlines. (Perl's default). - static ONE_LINE = 0x10; - // Make repetition operators default to non-greedy. - static NON_GREEDY = 0x20; - // allow Perl extensions: - // non-capturing parens - (?: ) - // non-greedy operators - *? +? ?? {}? - // flag edits - (?i) (?-i) (?i: ) - // i - FoldCase - // m - !OneLine - // s - DotNL - // U - NonGreedy - // line ends: \A \z - // \Q and \E to disable/enable metacharacters - // (?Pexpr) for named captures - // \C (any byte) is not supported. - static PERL_X = 0x40; - // Allow \p{Han}, \P{Han} for Unicode group and negation. - static UNICODE_GROUPS = 0x80; - // Regexp END_TEXT was $, not \z. Internal use only. - static WAS_DOLLAR = 0x100; +// Fold case during matching (case-insensitive). +const FOLD_CASE = 0x01; +// Treat pattern as a literal string instead of a regexp. +const LITERAL = 0x02; +// Allow character classes like [^a-z] and [[:space:]] to match newline. +const CLASS_NL = 0x04; +// Allow '.' to match newline. +const DOT_NL = 0x08; +// Treat ^ and $ as only matching at beginning and end of text, not +// around embedded newlines. (Perl's default). +const ONE_LINE = 0x10; +// Make repetition operators default to non-greedy. +const NON_GREEDY = 0x20; +// allow Perl extensions: +// non-capturing parens - (?: ) +// non-greedy operators - *? +? ?? {}? +// flag edits - (?i) (?-i) (?i: ) +// i - FoldCase +// m - !OneLine +// s - DotNL +// U - NonGreedy +// line ends: \A \z +// \Q and \E to disable/enable metacharacters +// (?Pexpr) for named captures +// \C (any byte) is not supported. +const PERL_X = 0x40; +// Allow \p{Han}, \P{Han} for Unicode group and negation. +const UNICODE_GROUPS = 0x80; +// Regexp END_TEXT was $, not \z. Internal use only. +const WAS_DOLLAR = 0x100; - static MATCH_NL = RE2Flags.CLASS_NL | RE2Flags.DOT_NL; - // As close to Perl as possible. - static PERL = - RE2Flags.CLASS_NL | - RE2Flags.ONE_LINE | - RE2Flags.PERL_X | - RE2Flags.UNICODE_GROUPS; - // POSIX syntax. - static POSIX = 0; - //// Anchors - static UNANCHORED = 0; - static ANCHOR_START = 1; - static ANCHOR_BOTH = 2; -} +const MATCH_NL = CLASS_NL | DOT_NL; +// As close to Perl as possible. +const PERL = CLASS_NL | ONE_LINE | PERL_X | UNICODE_GROUPS; +// POSIX syntax. +const POSIX = 0; +//// Anchors +const UNANCHORED = 0; +const ANCHOR_START = 1; +const ANCHOR_BOTH = 2; -export { RE2Flags }; +export { + UNANCHORED, + ANCHOR_BOTH, + NON_GREEDY, + FOLD_CASE, + LITERAL, + ONE_LINE, + WAS_DOLLAR, + DOT_NL, + UNICODE_GROUPS, + CLASS_NL, + PERL, + ANCHOR_START, + POSIX, + MATCH_NL, + PERL_X, +}; diff --git a/packages/re2/src/Simplify.ts b/packages/re2/src/Simplify.ts index 7491110..3cb87d2 100644 --- a/packages/re2/src/Simplify.ts +++ b/packages/re2/src/Simplify.ts @@ -1,274 +1,265 @@ -import { RE2Flags } from "./RE2Flags.js"; +import { NON_GREEDY } from "./RE2Flags.js"; import { Regexp } from "./Regexp.js"; -import { Unicode } from "./Unicode.js"; +import { MAX_RUNE } from "./Unicode.js"; -class Simplify { - // Simplify returns a regexp equivalent to re but without counted - // repetitions and with various other simplifications, such as - // rewriting /(?:a+)+/ to /a+/. The resulting regexp will execute - // correctly but its string representation will not produce the same - // parse tree, because capturing parentheses may have been duplicated - // or removed. For example, the simplified form for /(x){1,2}/ is - // /(x)(x)?/ but both parentheses capture as $1. The returned regexp - // may share structure with or be the original. - static simplify(re: Regexp): Regexp { - if (re === null) { - return null as any; +// simplify returns a regexp equivalent to re but without counted +// repetitions and with various other simplifications, such as +// rewriting /(?:a+)+/ to /a+/. The resulting regexp will execute +// correctly but its string representation will not produce the same +// parse tree, because capturing parentheses may have been duplicated +// or removed. For example, the simplified form for /(x){1,2}/ is +// /(x)(x)?/ but both parentheses capture as $1. The returned regexp +// may share structure with or be the original. +function simplify(re: Regexp): Regexp { + switch (re.op) { + case Regexp.Op.CAPTURE: { + const sub = simplify(re.subs[0]); + if (sub !== re.subs[0]) { + const nre = Regexp.fromRegexp(re); + nre.runes = []; + nre.subs = [sub]; + return nre; + } + return re; } - switch (re.op) { - case Regexp.Op.CAPTURE: { - const sub = Simplify.simplify(re.subs[0]); - if (sub !== re.subs[0]) { - const nre = Regexp.fromRegexp(re); - nre.runes = []; - nre.subs = [sub]; - return nre; - } - return re; - } + case Regexp.Op.CONCAT: + case Regexp.Op.ALTERNATE: { + const newSubs = []; + let changed = false; - case Regexp.Op.CONCAT: - case Regexp.Op.ALTERNATE: { - const newSubs = []; - let changed = false; + for (let i = 0; i < re.subs.length; i++) { + const sub = re.subs[i]; + const nsub = simplify(sub); + if (nsub !== sub) { + changed = true; + } - for (let i = 0; i < re.subs.length; i++) { - const sub = re.subs[i]; - const nsub = Simplify.simplify(sub); - if (nsub !== sub) { + if (re.op === Regexp.Op.CONCAT) { + // If any part of a CONCAT is mathematically impossible, + // the entire CONCAT sequence becomes impossible. + if (nsub.op === Regexp.Op.NO_MATCH) { + return new Regexp(Regexp.Op.NO_MATCH); + } + // Drop empty 0-width match nodes entirely from sequences + if (nsub.op === Regexp.Op.EMPTY_MATCH) { changed = true; + continue; } - - if (re.op === Regexp.Op.CONCAT) { - // If any part of a CONCAT is mathematically impossible, - // the entire CONCAT sequence becomes impossible. - if (nsub.op === Regexp.Op.NO_MATCH) { - return new Regexp(Regexp.Op.NO_MATCH); - } - // Drop empty 0-width match nodes entirely from sequences - if (nsub.op === Regexp.Op.EMPTY_MATCH) { - changed = true; - continue; - } - // Flatten nested concatenations - if (nsub.op === Regexp.Op.CONCAT) { - changed = true; - newSubs.push(...nsub.subs); - continue; - } - } else if (re.op === Regexp.Op.ALTERNATE) { - // Drop impossible branches from alternations - if (nsub.op === Regexp.Op.NO_MATCH) { - changed = true; - continue; - } - // Flatten nested alternations - if (nsub.op === Regexp.Op.ALTERNATE) { - changed = true; - newSubs.push(...nsub.subs); - continue; - } + // Flatten nested concatenations + if (nsub.op === Regexp.Op.CONCAT) { + changed = true; + newSubs.push(...nsub.subs); + continue; } - - newSubs.push(nsub); - } - - if (changed) { - // If we filtered out all nodes, return the mathematically correct fallback - if (newSubs.length === 0) { - return new Regexp( - re.op === Regexp.Op.CONCAT - ? Regexp.Op.EMPTY_MATCH - : Regexp.Op.NO_MATCH, - ); + } else if (re.op === Regexp.Op.ALTERNATE) { + // Drop impossible branches from alternations + if (nsub.op === Regexp.Op.NO_MATCH) { + changed = true; + continue; } - // If only 1 node remains, we don't need a CONCAT/ALT container at all - if (newSubs.length === 1) { - return newSubs[0]; + // Flatten nested alternations + if (nsub.op === Regexp.Op.ALTERNATE) { + changed = true; + newSubs.push(...nsub.subs); + continue; } - - const nre = Regexp.fromRegexp(re); - nre.runes = []; - nre.subs = newSubs; - return nre; } - return re; + newSubs.push(nsub); } - case Regexp.Op.CHAR_CLASS: { - if (re.runes === null) return re; - - // Empty character classes match nothing. - if (re.runes.length === 0) { - return new Regexp(Regexp.Op.NO_MATCH); + if (changed) { + // If we filtered out all nodes, return the mathematically correct fallback + if (newSubs.length === 0) { + return new Regexp( + re.op === Regexp.Op.CONCAT + ? Regexp.Op.EMPTY_MATCH + : Regexp.Op.NO_MATCH, + ); } - // Full character classes match everything. - if ( - re.runes.length === 2 && - re.runes[0] === 0 && - re.runes[1] === Unicode.MAX_RUNE - ) { - return new Regexp(Regexp.Op.ANY_CHAR); + // If only 1 node remains, we don't need a CONCAT/ALT container at all + if (newSubs.length === 1) { + return newSubs[0]; } - // Standard catch-all except newline - if ( - re.runes.length === 4 && - re.runes[0] === 0 && - re.runes[1] === 0x0a - 1 && - re.runes[2] === 0x0a + 1 && - re.runes[3] === Unicode.MAX_RUNE - ) { - return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL); - } - return re; + + const nre = Regexp.fromRegexp(re); + nre.runes = []; + nre.subs = newSubs; + return nre; } - case Regexp.Op.STAR: - case Regexp.Op.PLUS: - case Regexp.Op.QUEST: { - const sub = Simplify.simplify(re.subs[0]); - return Simplify.simplify1(re.op, re.flags, sub, re); + return re; + } + + case Regexp.Op.CHAR_CLASS: { + if (re.runes === null) return re; + + // Empty character classes match nothing. + if (re.runes.length === 0) { + return new Regexp(Regexp.Op.NO_MATCH); + } + // Full character classes match everything. + if ( + re.runes.length === 2 && + re.runes[0] === 0 && + re.runes[1] === MAX_RUNE + ) { + return new Regexp(Regexp.Op.ANY_CHAR); } + // Standard catch-all except newline + if ( + re.runes.length === 4 && + re.runes[0] === 0 && + re.runes[1] === 0x0a - 1 && + re.runes[2] === 0x0a + 1 && + re.runes[3] === MAX_RUNE + ) { + return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL); + } + return re; + } - case Regexp.Op.REPEAT: { - // Special special case: x{0} matches the empty string - // and doesn't even need to consider x. - if (re.min === 0 && re.max === 0) { - return new Regexp(Regexp.Op.EMPTY_MATCH); - } - // The fun begins. - const sub = Simplify.simplify(re.subs[0]); + case Regexp.Op.STAR: + case Regexp.Op.PLUS: + case Regexp.Op.QUEST: { + const sub = simplify(re.subs[0]); + return simplify1(re.op, re.flags, sub, re); + } - // x{n,} means at least n matches of x. - if (re.max === -1) { - // Special case: x{0,} is x*. - if (re.min === 0) { - return Simplify.simplify1(Regexp.Op.STAR, re.flags, sub, null); - } - // Special case: x{1,} is x+. - if (re.min === 1) { - return Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null); - } - // General case: x{4,} is xxxx+. - const nre = new Regexp(Regexp.Op.CONCAT); - const subs = []; - for (let i = 0; i < re.min - 1; i++) { - subs.push(sub); - } - subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null)); - nre.subs = subs.slice(0); + case Regexp.Op.REPEAT: { + // Special special case: x{0} matches the empty string + // and doesn't even need to consider x. + if (re.min === 0 && re.max === 0) { + return new Regexp(Regexp.Op.EMPTY_MATCH); + } + // The fun begins. + const sub = simplify(re.subs[0]); - // Ensure newly created CONCAT is properly flattened - return Simplify.simplify(nre); + // x{n,} means at least n matches of x. + if (re.max === -1) { + // Special case: x{0,} is x*. + if (re.min === 0) { + return simplify1(Regexp.Op.STAR, re.flags, sub, null); } - // Special case x{0} handled above. - - // Special case: x{1} is just x. - if (re.min === 1 && re.max === 1) { - return sub; + // Special case: x{1,} is x+. + if (re.min === 1) { + return simplify1(Regexp.Op.PLUS, re.flags, sub, null); + } + // General case: x{4,} is xxxx+. + const nre = new Regexp(Regexp.Op.CONCAT); + const subs = []; + for (let i = 0; i < re.min - 1; i++) { + subs.push(sub); } + subs.push(simplify1(Regexp.Op.PLUS, re.flags, sub, null)); + nre.subs = subs.slice(0); - // General case: x{n,m} means n copies of x and m copies of x? - // The machine will do less work if we nest the final m copies, - // so that x{2,5} = xx(x(x(x)?)?)? + // Ensure newly created CONCAT is properly flattened + return simplify(nre); + } + // Special case x{0} handled above. - // Build leading prefix: xx. - let prefixSubs = null; - if (re.min > 0) { - prefixSubs = []; - for (let i = 0; i < re.min; i++) { - prefixSubs.push(sub); - } - } + // Special case: x{1} is just x. + if (re.min === 1 && re.max === 1) { + return sub; + } - // Build and attach suffix: (x(x(x)?)?)? - if (re.max > re.min) { - let suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, sub, null); - for (let i = re.min + 1; i < re.max; i++) { - const nre2 = new Regexp(Regexp.Op.CONCAT); - nre2.subs = [sub, suffix]; - suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, nre2, null); - } + // General case: x{n,m} means n copies of x and m copies of x? + // The machine will do less work if we nest the final m copies, + // so that x{2,5} = xx(x(x(x)?)?)? - if (prefixSubs === null) { - return suffix; - } - prefixSubs.push(suffix); + // Build leading prefix: xx. + let prefixSubs = null; + if (re.min > 0) { + prefixSubs = []; + for (let i = 0; i < re.min; i++) { + prefixSubs.push(sub); } + } - if (prefixSubs !== null) { - const prefix = new Regexp(Regexp.Op.CONCAT); - prefix.subs = prefixSubs.slice(0); - // Ensure newly created CONCAT is properly flattened - return Simplify.simplify(prefix); + // Build and attach suffix: (x(x(x)?)?)? + if (re.max > re.min) { + let suffix = simplify1(Regexp.Op.QUEST, re.flags, sub, null); + for (let i = re.min + 1; i < re.max; i++) { + const nre2 = new Regexp(Regexp.Op.CONCAT); + nre2.subs = [sub, suffix]; + suffix = simplify1(Regexp.Op.QUEST, re.flags, nre2, null); } - // Some degenerate case like min > max or min < max < 0. - // Handle as impossible match. - return new Regexp(Regexp.Op.NO_MATCH); + if (prefixSubs === null) { + return suffix; + } + prefixSubs.push(suffix); } - } - return re; - } - // simplify1 implements Simplify for the unary OpStar, - // OpPlus, and OpQuest operators. It returns the simple regexp - // equivalent to - // - // Regexp{Op: op, Flags: flags, Sub: {sub}} - // - // under the assumption that sub is already simple, and - // without first allocating that structure. If the regexp - // to be returned turns out to be equivalent to re, simplify1 - // returns re instead. - // - // simplify1 is factored out of Simplify because the implementation - // for other operators generates these unary expressions. - // Letting them call simplify1 makes sure the expressions they - // generate are simple. - static simplify1( - op: number, - flags: number, - sub: Regexp, - re: Regexp | null, - ): Regexp { - // Special case: repeat the empty string as much as - // you want, but it's still the empty string. - if (sub.op === Regexp.Op.EMPTY_MATCH) { - return sub; - } + if (prefixSubs !== null) { + const prefix = new Regexp(Regexp.Op.CONCAT); + prefix.subs = prefixSubs.slice(0); + // Ensure newly created CONCAT is properly flattened + return simplify(prefix); + } - // Handle impossible targets gracefully. - // e.g. Trying to match "NO_MATCH" 0 or 1 times (QUEST/STAR) evaluates to EMPTY_MATCH. - if (sub.op === Regexp.Op.NO_MATCH) { - if (op === Regexp.Op.PLUS) return sub; // 1+ times is impossible - return new Regexp(Regexp.Op.EMPTY_MATCH); + // Some degenerate case like min > max or min < max < 0. + // Handle as impossible match. + return new Regexp(Regexp.Op.NO_MATCH); } + } + return re; +} - // The operators are idempotent if the flags match. - if ( - op === sub.op && - (flags & RE2Flags.NON_GREEDY) === (sub.flags & RE2Flags.NON_GREEDY) - ) { - return sub; - } +// simplify1 implements Simplify for the unary OpStar, +// OpPlus, and OpQuest operators. It returns the simple regexp +// equivalent to +// +// Regexp{Op: op, Flags: flags, Sub: {sub}} +// +// under the assumption that sub is already simple, and +// without first allocating that structure. If the regexp +// to be returned turns out to be equivalent to re, simplify1 +// returns re instead. +// +// simplify1 is factored out of Simplify because the implementation +// for other operators generates these unary expressions. +// Letting them call simplify1 makes sure the expressions they +// generate are simple. +function simplify1( + op: number, + flags: number, + sub: Regexp, + re: Regexp | null, +): Regexp { + // Special case: repeat the empty string as much as + // you want, but it's still the empty string. + if (sub.op === Regexp.Op.EMPTY_MATCH) { + return sub; + } - if ( - re !== null && - re.op === op && - (re.flags & RE2Flags.NON_GREEDY) === (flags & RE2Flags.NON_GREEDY) && - sub === re.subs[0] - ) { - return re; - } + // Handle impossible targets gracefully. + // e.g. Trying to match "NO_MATCH" 0 or 1 times (QUEST/STAR) evaluates to EMPTY_MATCH. + if (sub.op === Regexp.Op.NO_MATCH) { + if (op === Regexp.Op.PLUS) return sub; // 1+ times is impossible + return new Regexp(Regexp.Op.EMPTY_MATCH); + } - const nre = new Regexp(op); - nre.flags = flags; - nre.subs = [sub]; - return nre; + // The operators are idempotent if the flags match. + if (op === sub.op && (flags & NON_GREEDY) === (sub.flags & NON_GREEDY)) { + return sub; } + + if ( + re !== null && + re.op === op && + (re.flags & NON_GREEDY) === (flags & NON_GREEDY) && + sub === re.subs[0] + ) { + return re; + } + + const nre = new Regexp(op); + nre.flags = flags; + nre.subs = [sub]; + return nre; } -export { Simplify }; +export { simplify }; diff --git a/packages/re2/src/Unicode.ts b/packages/re2/src/Unicode.ts index 5819d69..7a4edc5 100644 --- a/packages/re2/src/Unicode.ts +++ b/packages/re2/src/Unicode.ts @@ -1,163 +1,176 @@ import { UnicodeRangeTable } from "./UnicodeRangeTable.js"; import { UnicodeTables } from "./UnicodeTables.js"; + /** * Utilities for dealing with Unicode better than JS does. */ -class Unicode { - // The highest legal rune value. - static MAX_RUNE = 0x10ffff; - // The highest legal ASCII value. - static MAX_ASCII = 0x7f; - // The highest legal Latin-1 value. - static MAX_LATIN1 = 0xff; - // The highest legal Basic Multilingual Plane (BMP) value. - static MAX_BMP = 0xffff; - // Minimum and maximum runes involved in folding. - // Checked during test. - static MIN_FOLD = 0x0041; - static MAX_FOLD = 0x1e943; - - static MIN_HIGH_SURROGATE = 0xd800; - static MAX_HIGH_SURROGATE = 0xdbff; - static MIN_LOW_SURROGATE = 0xdc00; - static MAX_LOW_SURROGATE = 0xdfff; - static MIN_SUPPLEMENTARY_CODE_POINT = 0x10000; - - // is32 uses binary search to test whether rune is in the specified - // slice of 32-bit ranges. - static is32(ranges: UnicodeRangeTable, r: number): boolean { - // binary search over ranges - let lo = 0; - let hi = ranges.length; - while (lo < hi) { - const m = lo + Math.floor((hi - lo) / 2); - - const rlo = ranges.getLo(m); - const rhi = ranges.getHi(m); - if (rlo <= r && r <= rhi) { - const stride = ranges.getStride(m); - return (r - rlo) % stride === 0; - } - if (r < rlo) { - hi = m; - } else { - lo = m + 1; - } +// The highest legal rune value. +const MAX_RUNE = 0x10ffff; +// The highest legal ASCII value. +const MAX_ASCII = 0x7f; +// The highest legal Latin-1 value. +const MAX_LATIN1 = 0xff; +// The highest legal Basic Multilingual Plane (BMP) value. +const MAX_BMP = 0xffff; +// Minimum and maximum runes involved in folding. +// Checked during test. +const MIN_FOLD = 0x0041; +const MAX_FOLD = 0x1e943; + +const MIN_HIGH_SURROGATE = 0xd800; +const MAX_HIGH_SURROGATE = 0xdbff; +const MIN_LOW_SURROGATE = 0xdc00; +const MAX_LOW_SURROGATE = 0xdfff; +const MIN_SUPPLEMENTARY_CODE_POINT = 0x10000; + +// is32 uses binary search to test whether rune is in the specified +// slice of 32-bit ranges. +function is32(ranges: UnicodeRangeTable, r: number): boolean { + // binary search over ranges + let lo = 0; + let hi = ranges.length; + while (lo < hi) { + const m = lo + Math.floor((hi - lo) / 2); + + const rlo = ranges.getLo(m); + const rhi = ranges.getHi(m); + if (rlo <= r && r <= rhi) { + const stride = ranges.getStride(m); + return (r - rlo) % stride === 0; + } + if (r < rlo) { + hi = m; + } else { + lo = m + 1; } - return false; } + return false; +} - // is tests whether rune is in the specified table of ranges. - static is(ranges: UnicodeRangeTable, r: number): boolean { - // Fast path for Latin-1 characters using linear search. - if (r <= this.MAX_LATIN1) { - for (let i = 0; i < ranges.length; i++) { - const rhi = ranges.getHi(i); - if (r > rhi) { - continue; - } - - const rlo = ranges.getLo(i); - if (r < rlo) { - return false; - } - - const stride = ranges.getStride(i); - return (r - rlo) % stride === 0; +// is tests whether rune is in the specified table of ranges. +function is(ranges: UnicodeRangeTable, r: number): boolean { + // Fast path for Latin-1 characters using linear search. + if (r <= MAX_LATIN1) { + for (let i = 0; i < ranges.length; i++) { + const rhi = ranges.getHi(i); + if (r > rhi) { + continue; } - return false; - } - // Fallback to binary search for runes outside Latin-1 - return ranges.length > 0 && r >= ranges.getLo(0) && this.is32(ranges, r); - } + const rlo = ranges.getLo(i); + if (r < rlo) { + return false; + } - // isUpper reports whether the rune is an upper case letter. - static isUpper(r: number): boolean { - if (r <= this.MAX_LATIN1) { - const s = String.fromCodePoint(r); - return s.toUpperCase() === s && s.toLowerCase() !== s; + const stride = ranges.getStride(i); + return (r - rlo) % stride === 0; } - return this.is(UnicodeTables.Upper, r); + return false; } - // simpleFold iterates over Unicode code points equivalent under - // the Unicode-defined simple case folding. Among the code points - // equivalent to rune (including rune itself), SimpleFold returns the - // smallest r >= rune if one exists, or else the smallest r >= 0. - // - // For example: - // SimpleFold('A') = 'a' - // SimpleFold('a') = 'A' - // - // SimpleFold('K') = 'k' - // SimpleFold('k') = '\u212A' (Kelvin symbol, K) - // SimpleFold('\u212A') = 'K' - // - // SimpleFold('1') = '1' - // - // Derived from Go's unicode.SimpleFold. - // - static simpleFold(r: number): number { - // Consult caseOrbit table for special cases (3+ element cycles, lossy - // mappings like ſ→S, and Turkic-specific self-loops). - if (UnicodeTables.CASE_ORBIT!.has(r)) { - return UnicodeTables.CASE_ORBIT!.get(r)!; - } + // Fallback to binary search for runes outside Latin-1 + return ranges.length > 0 && r >= ranges.getLo(0) && is32(ranges, r); +} - // Fallback for 2-element orbits: use raw native case conversion. - // The length check rejects multi-char results (e.g., ß→SS) which - // would otherwise be truncated to a non-equivalent codepoint. +// isUpper reports whether the rune is an upper case letter. +function isUpper(r: number): boolean { + if (r <= MAX_LATIN1) { const s = String.fromCodePoint(r); - const lower = s.toLowerCase(); - if (lower.length === s.length) { - const lowerCp = lower.codePointAt(0)!; - if (lowerCp !== r) return lowerCp; - } - const upper = s.toUpperCase(); - if (upper.length === s.length) { - const upperCp = upper.codePointAt(0)!; - if (upperCp !== r) return upperCp; - } - return r; + return s.toUpperCase() === s && s.toLowerCase() !== s; } + return is(UnicodeTables.Upper, r); +} - // equalsIgnoreCase performs case-insensitive equality comparison - // on the given runes |r1| and |r2|, with special consideration - // for the likely scenario where both runes are ASCII characters. - // If non-ASCII, Unicode case folding will be performed on |r1| - // to compare it to |r2|. - // -1 is interpreted as the end-of-file mark. - static equalsIgnoreCase(r1: number, r2: number): boolean { - // Runes already match, or one of them is EOF - if (r1 < 0 || r2 < 0 || r1 === r2) { - return true; - } +// simpleFold iterates over Unicode code points equivalent under +// the Unicode-defined simple case folding. Among the code points +// equivalent to rune (including rune itself), SimpleFold returns the +// smallest r >= rune if one exists, or else the smallest r >= 0. +// +// For example: +// SimpleFold('A') = 'a' +// SimpleFold('a') = 'A' +// +// SimpleFold('K') = 'k' +// SimpleFold('k') = '\u212A' (Kelvin symbol, K) +// SimpleFold('\u212A') = 'K' +// +// SimpleFold('1') = '1' +// +// Derived from Go's unicode.SimpleFold. +// +function simpleFold(r: number): number { + // Consult caseOrbit table for special cases (3+ element cycles, lossy + // mappings like ſ→S, and Turkic-specific self-loops). + if (UnicodeTables.CASE_ORBIT!.has(r)) { + return UnicodeTables.CASE_ORBIT!.get(r)!; + } - // Fast path for the common case where both runes are ASCII characters. - // Coerces both runes to lowercase if applicable. - if (r1 <= this.MAX_ASCII && r2 <= this.MAX_ASCII) { - if (0x41 <= r1 && r1 <= 0x5a) { - r1 |= 0x20; - } + // Fallback for 2-element orbits: use raw native case conversion. + // The length check rejects multi-char results (e.g., ß→SS) which + // would otherwise be truncated to a non-equivalent codepoint. + const s = String.fromCodePoint(r); + const lower = s.toLowerCase(); + if (lower.length === s.length) { + const lowerCp = lower.codePointAt(0)!; + if (lowerCp !== r) return lowerCp; + } + const upper = s.toUpperCase(); + if (upper.length === s.length) { + const upperCp = upper.codePointAt(0)!; + if (upperCp !== r) return upperCp; + } + return r; +} - if (0x41 <= r2 && r2 <= 0x5a) { - r2 |= 0x20; - } +// equalsIgnoreCase performs case-insensitive equality comparison +// on the given runes |r1| and |r2|, with special consideration +// for the likely scenario where both runes are ASCII characters. +// If non-ASCII, Unicode case folding will be performed on |r1| +// to compare it to |r2|. +// -1 is interpreted as the end-of-file mark. +function equalsIgnoreCase(r1: number, r2: number): boolean { + // Runes already match, or one of them is EOF + if (r1 < 0 || r2 < 0 || r1 === r2) { + return true; + } - return r1 === r2; + // Fast path for the common case where both runes are ASCII characters. + // Coerces both runes to lowercase if applicable. + if (r1 <= MAX_ASCII && r2 <= MAX_ASCII) { + if (0x41 <= r1 && r1 <= 0x5a) { + r1 |= 0x20; } - // Fall back to full Unicode case folding otherwise. - // Invariant: r1 must be non-negative - for (let r = this.simpleFold(r1); r !== r1; r = this.simpleFold(r)) { - if (r === r2) { - return true; - } + if (0x41 <= r2 && r2 <= 0x5a) { + r2 |= 0x20; } - return false; + return r1 === r2; + } + + // Fall back to full Unicode case folding otherwise. + // Invariant: r1 must be non-negative + for (let r = simpleFold(r1); r !== r1; r = simpleFold(r)) { + if (r === r2) { + return true; + } } + + return false; } -export { Unicode }; +export { + MAX_RUNE, + MIN_FOLD, + MAX_FOLD, + simpleFold, + MAX_ASCII, + equalsIgnoreCase, + MIN_SUPPLEMENTARY_CODE_POINT, + MIN_LOW_SURROGATE, + MIN_HIGH_SURROGATE, + MAX_LOW_SURROGATE, + MAX_HIGH_SURROGATE, + MAX_BMP, + isUpper, +}; diff --git a/packages/re2/src/Utils.ts b/packages/re2/src/Utils.ts index 1d51f6c..1f0e870 100644 --- a/packages/re2/src/Utils.ts +++ b/packages/re2/src/Utils.ts @@ -1,119 +1,132 @@ -import { Unicode } from "./Unicode.js"; +import { MAX_BMP } from "./Unicode.js"; + /** * Various constants and helper utilities. */ -class Utils { - static METACHARACTERS = "\\.+*?()|[]{}^$"; +const METACHARACTERS = "\\.+*?()|[]{}^$"; - //// EMPTY_* flags - static EMPTY_BEGIN_LINE = 0x01; - static EMPTY_END_LINE = 0x02; - static EMPTY_BEGIN_TEXT = 0x04; - static EMPTY_END_TEXT = 0x08; - static EMPTY_WORD_BOUNDARY = 0x10; - static EMPTY_NO_WORD_BOUNDARY = 0x20; - static EMPTY_ALL = -1; +//// EMPTY_* flags +const EMPTY_BEGIN_LINE = 0x01; +const EMPTY_END_LINE = 0x02; +const EMPTY_BEGIN_TEXT = 0x04; +const EMPTY_END_TEXT = 0x08; +const EMPTY_WORD_BOUNDARY = 0x10; +const EMPTY_NO_WORD_BOUNDARY = 0x20; - static emptyInts(): number[] { - return []; - } +function emptyInts(): number[] { + return []; +} - // Returns true iff |c| is an ASCII letter or decimal digit. - static isalnum(c: number): boolean { - return ( - (0x30 <= c && c <= 0x39) || - (0x61 <= c && c <= 0x7a) || - (0x41 <= c && c <= 0x5a) - ); - } +// Returns true iff |c| is an ASCII letter or decimal digit. +function isalnum(c: number): boolean { + return ( + (0x30 <= c && c <= 0x39) || + (0x61 <= c && c <= 0x7a) || + (0x41 <= c && c <= 0x5a) + ); +} - // If |c| is an ASCII hex digit, returns its value, otherwise -1. - static unhex(c: number): number { - if (0x30 <= c && c <= 0x39) { - return c - 0x30; - } - if (0x61 <= c && c <= 0x66) { - return c - 0x61 + 10; - } - if (0x41 <= c && c <= 0x46) { - return c - 0x41 + 10; - } - return -1; +// If |c| is an ASCII hex digit, returns its value, otherwise -1. +function unhex(c: number): number { + if (0x30 <= c && c <= 0x39) { + return c - 0x30; } - - // Returns the array of runes in the specified UTF-16 string. - static stringToRunes(str: string): number[] { - return Array.from(String(str)).map((s) => s.codePointAt(0)!); + if (0x61 <= c && c <= 0x66) { + return c - 0x61 + 10; } - - // Returns the Java UTF-16 string containing the single rune |r|. - static runeToString(r: number): string { - return String.fromCodePoint(r); + if (0x41 <= c && c <= 0x46) { + return c - 0x41 + 10; } + return -1; +} - // isWordRune reports whether r is consider a ``word character'' - // during the evaluation of the \b and \B zero-width assertions. - // These assertions are ASCII-only: the word characters are [A-Za-z0-9_]. - static isWordRune(r: number): boolean { - return ( - (0x61 <= r && r <= 0x7a) || - (0x41 <= r && r <= 0x5a) || - (0x30 <= r && r <= 0x39) || - r === 0x5f - ); - } +// Returns the array of runes in the specified UTF-16 string. +function stringToRunes(str: string): number[] { + return Array.from(String(str)).map((s) => s.codePointAt(0)!); +} - // emptyOpContext returns the zero-width assertions satisfied at the position - // between the runes r1 and r2, a bitmask of EMPTY_* flags. - // Passing r1 == -1 indicates that the position is at the beginning of the - // text. - // Passing r2 == -1 indicates that the position is at the end of the text. - // eslint-disable-next-line no-warning-comments - // TODO(adonovan): move to Machine. - static emptyOpContext(r1: number, r2: number): number { - let op = 0; - if (r1 < 0) { - op |= this.EMPTY_BEGIN_TEXT | this.EMPTY_BEGIN_LINE; - } - if (r1 === 0x0a) { - op |= this.EMPTY_BEGIN_LINE; - } - if (r2 < 0) { - op |= this.EMPTY_END_TEXT | this.EMPTY_END_LINE; - } - if (r2 === 0x0a) { - op |= this.EMPTY_END_LINE; - } - if (this.isWordRune(r1) !== this.isWordRune(r2)) { - op |= this.EMPTY_WORD_BOUNDARY; - } else { - op |= this.EMPTY_NO_WORD_BOUNDARY; - } - return op; - } +// Returns the Java UTF-16 string containing the single rune |r|. +function runeToString(r: number): string { + return String.fromCodePoint(r); +} - /** - * Returns a string that quotes all regular expression metacharacters inside the argument text; - * the returned string is a regular expression matching the literal text. For example, - * {@code quoteMeta("[foo]").equals("\\[foo\\]")}. - * @param {string} s - * @returns {string} - */ - static quoteMeta(str: string): string { - return str - .split("") // A char loop is correct because all metacharacters fit in one UTF-16 code. - .map((s) => { - if (this.METACHARACTERS.indexOf(s) >= 0) { - return `\\${s}`; - } - return s; - }) - .join(""); - } +// isWordRune reports whether r is consider a ``word character'' +// during the evaluation of the \b and \B zero-width assertions. +// These assertions are ASCII-only: the word characters are [A-Za-z0-9_]. +function isWordRune(r: number): boolean { + return ( + (0x61 <= r && r <= 0x7a) || + (0x41 <= r && r <= 0x5a) || + (0x30 <= r && r <= 0x39) || + r === 0x5f + ); +} - static charCount(codePoint: number): number { - return codePoint > Unicode.MAX_BMP ? 2 : 1; +// emptyOpContext returns the zero-width assertions satisfied at the position +// between the runes r1 and r2, a bitmask of EMPTY_* flags. +// Passing r1 == -1 indicates that the position is at the beginning of the +// text. +// Passing r2 == -1 indicates that the position is at the end of the text. +// eslint-disable-next-line no-warning-comments +// TODO(adonovan): move to Machine. +function emptyOpContext(r1: number, r2: number): number { + let op = 0; + if (r1 < 0) { + op |= EMPTY_BEGIN_TEXT | EMPTY_BEGIN_LINE; + } + if (r1 === 0x0a) { + op |= EMPTY_BEGIN_LINE; + } + if (r2 < 0) { + op |= EMPTY_END_TEXT | EMPTY_END_LINE; + } + if (r2 === 0x0a) { + op |= EMPTY_END_LINE; + } + if (isWordRune(r1) !== isWordRune(r2)) { + op |= EMPTY_WORD_BOUNDARY; + } else { + op |= EMPTY_NO_WORD_BOUNDARY; } + return op; +} + +/** + * Returns a string that quotes all regular expression metacharacters inside the argument text; + * the returned string is a regular expression matching the literal text. For example, + * {@code quoteMeta("[foo]").equals("\\[foo\\]")}. + * @param {string} s + * @returns {string} + */ +function quoteMeta(str: string): string { + return str + .split("") // A char loop is correct because all metacharacters fit in one UTF-16 code. + .map((s) => { + if (METACHARACTERS.indexOf(s) >= 0) { + return `\\${s}`; + } + return s; + }) + .join(""); +} + +function charCount(codePoint: number): number { + return codePoint > MAX_BMP ? 2 : 1; } -export { Utils }; +export { + emptyInts, + runeToString, + emptyOpContext, + charCount, + stringToRunes, + isalnum, + unhex, + quoteMeta, + EMPTY_BEGIN_LINE, + EMPTY_END_LINE, + EMPTY_WORD_BOUNDARY, + EMPTY_BEGIN_TEXT, + EMPTY_END_TEXT, + EMPTY_NO_WORD_BOUNDARY, +}; diff --git a/packages/re2/src/__tests__/BugHunt.test.ts b/packages/re2/src/__tests__/BugHunt.test.ts index 4a009ef..20b5fe7 100644 --- a/packages/re2/src/__tests__/BugHunt.test.ts +++ b/packages/re2/src/__tests__/BugHunt.test.ts @@ -7,8 +7,8 @@ import { describe, test } from "node:test"; import * as assert from "node:assert/strict"; import { RE2JS } from "../index.js"; import { fromUTF16 } from "../MachineInput.js"; -import { RE2Flags } from "../RE2Flags.js"; -import { Unicode } from "../Unicode.js"; +import { ANCHOR_START } from "../RE2Flags.js"; +import { equalsIgnoreCase, simpleFold } from "../Unicode.js"; describe("bug-hunt verification", () => { // Phase 1c: DFA.match ANCHOR_START with pos>0 @@ -18,7 +18,7 @@ describe("bug-hunt verification", () => { const result = (re as any).re2Input.executeEngine( input, 3, - RE2Flags.ANCHOR_START, + ANCHOR_START, 0, ); assert.notStrictEqual(result, null); @@ -30,7 +30,7 @@ describe("bug-hunt verification", () => { const result = (re as any).re2Input.executeEngine( input, 1, - RE2Flags.ANCHOR_START, + ANCHOR_START, 0, ); assert.strictEqual(result, null); @@ -38,9 +38,9 @@ describe("bug-hunt verification", () => { // Phase 1b: equalsIgnoreCase EOF handling test("equalsIgnoreCase(-1, X) returns true per current implementation", () => { - assert.strictEqual(Unicode.equalsIgnoreCase(-1, 0x41), true); - assert.strictEqual(Unicode.equalsIgnoreCase(0x41, -1), true); - assert.strictEqual(Unicode.equalsIgnoreCase(-1, -1), true); + assert.strictEqual(equalsIgnoreCase(-1, 0x41), true); + assert.strictEqual(equalsIgnoreCase(0x41, -1), true); + assert.strictEqual(equalsIgnoreCase(-1, -1), true); }); // Phase 1d: Simplify REPEAT aliasing @@ -64,7 +64,7 @@ describe("bug-hunt verification", () => { const checkOrbit = (start: number): boolean => { let r = start; for (let i = 0; i < 4; i++) { - r = Unicode.simpleFold(r); + r = simpleFold(r); if (r === start) return true; } return false; @@ -77,7 +77,7 @@ describe("bug-hunt verification", () => { assert.strictEqual(checkOrbit(0x0073), true); // s assert.strictEqual(checkOrbit(0x017f), true); // long s - assert.strictEqual(Unicode.simpleFold(0x0131), 0x0131); + assert.strictEqual(simpleFold(0x0131), 0x0131); }); test("simpleFold sweep: no non-closing orbit across BMP", () => { @@ -88,7 +88,7 @@ describe("bug-hunt verification", () => { let r = cp; let closed = false; for (let i = 0; i < 8; i++) { - r = Unicode.simpleFold(r); + r = simpleFold(r); if (r === cp) { closed = true; break; diff --git a/packages/re2/src/__tests__/CharClass.test.ts b/packages/re2/src/__tests__/CharClass.test.ts index 39f9f64..78641bf 100644 --- a/packages/re2/src/__tests__/CharClass.test.ts +++ b/packages/re2/src/__tests__/CharClass.test.ts @@ -1,11 +1,11 @@ import { describe, test } from "node:test"; import * as assert from "node:assert/strict"; -import { RE2Flags } from "../RE2Flags.js"; +import { FOLD_CASE } from "../RE2Flags.js"; import { CharGroup, getPerlGroups } from "../CharGroup.js"; import { CharClass } from "../CharClass.js"; -import { Unicode } from "../Unicode.js"; +import { MAX_FOLD, MAX_RUNE } from "../Unicode.js"; import { UnicodeRangeTable } from "../UnicodeRangeTable.js"; -import { Utils } from "../Utils.js"; +import { stringToRunes } from "../Utils.js"; import { codePoint } from "../__utils__/chars.js"; describe(".cleanClass", () => { @@ -52,16 +52,16 @@ describe(".cleanClass", () => { [10, 23], ], [ - [0, Unicode.MAX_RUNE], - [0, Unicode.MAX_RUNE], + [0, MAX_RUNE], + [0, MAX_RUNE], ], [ [0, 50], [0, 50], ], [ - [50, Unicode.MAX_RUNE], - [50, Unicode.MAX_RUNE], + [50, MAX_RUNE], + [50, MAX_RUNE], ], ]; @@ -82,13 +82,13 @@ describe(".appendLiteral", () => { [["b", "f"], "a", 0, ["a", "f"]], [["a", "f"], "g", 0, ["a", "g"]], [["a", "f"], "A", 0, ["a", "f", "A", "A"]], - [[], "a", RE2Flags.FOLD_CASE, ["a", "a", "A", "A"]], - [["a", "f"], "a", RE2Flags.FOLD_CASE, ["a", "f", "A", "A"]], - [["b", "f"], "a", RE2Flags.FOLD_CASE, ["a", "f", "A", "A"]], - [["a", "f"], "g", RE2Flags.FOLD_CASE, ["a", "g", "G", "G"]], - [["a", "f"], "A", RE2Flags.FOLD_CASE, ["a", "f", "A", "A"]], + [[], "a", FOLD_CASE, ["a", "a", "A", "A"]], + [["a", "f"], "a", FOLD_CASE, ["a", "f", "A", "A"]], + [["b", "f"], "a", FOLD_CASE, ["a", "f", "A", "A"]], + [["a", "f"], "g", FOLD_CASE, ["a", "g", "G", "G"]], + [["a", "f"], "A", FOLD_CASE, ["a", "f", "A", "A"]], [["a", "f"], " ", 0, ["a", "f", " ", " "]], - [["a", "f"], " ", RE2Flags.FOLD_CASE, ["a", "f", " ", " "]], + [["a", "f"], " ", FOLD_CASE, ["a", "f", " ", " "]], ]; for (const [input, literal, flags, expected] of cases) { @@ -105,7 +105,7 @@ describe(".appendLiteral", () => { describe(".appendFoldedRange", () => { const cases: [number, number, number[]][] = [ - [10, Unicode.MAX_FOLD + 20, [10, Unicode.MAX_FOLD + 20]], + [10, MAX_FOLD + 20, [10, MAX_FOLD + 20]], [codePoint(" "), codePoint("&"), [" ", "&"].map(codePoint)], [codePoint(" "), codePoint("C"), [" ", "C", "a", "c"].map(codePoint)], [0x1e853, 0x1e9e4, [0x1e944, 0x1e9e4, 0x1e853, 0x1e920, 0x1e920, 0x1e943]], @@ -158,7 +158,7 @@ describe(".appendNegatedClass", () => { 0, codePoint("a"), codePoint("g"), - Unicode.MAX_RUNE, + MAX_RUNE, ], ); }); @@ -171,12 +171,12 @@ describe(".appendFoldedClass", () => { [ [], ["a", "z"].map(codePoint), - Utils.stringToRunes(`akAK${k}${k}lsLS${s}${s}tzTZ`), + stringToRunes(`akAK${k}${k}lsLS${s}${s}tzTZ`), ], [ ["a", "f"].map(codePoint), ["c", "t"].map(codePoint), - Utils.stringToRunes(`akCK${k}${k}lsLS${s}${s}ttTT`), + stringToRunes(`akCK${k}${k}lsLS${s}${s}ttTT`), ], [ ["c", "t"].map(codePoint), @@ -197,10 +197,10 @@ describe(".appendFoldedClass", () => { describe(".negateClass", () => { const cases: [number[], number[]][] = [ - [[], [codePoint("\0"), Unicode.MAX_RUNE]], + [[], [codePoint("\0"), MAX_RUNE]], [ ["A", "Z"].map(codePoint), - [codePoint("\0"), codePoint("@"), codePoint("["), Unicode.MAX_RUNE], + [codePoint("\0"), codePoint("@"), codePoint("["), MAX_RUNE], ], [ ["A", "Z", "a", "z"].map(codePoint), @@ -210,7 +210,7 @@ describe(".negateClass", () => { codePoint("["), codePoint("`"), codePoint("{"), - Unicode.MAX_RUNE, + MAX_RUNE, ], ], ]; @@ -246,14 +246,14 @@ describe(".appendTable", () => { new UnicodeRangeTable( new Uint32Array([codePoint("Ā"), codePoint("Į"), 2]), ), - Utils.stringToRunes("ĀĀĂĂĄĄĆĆĈĈĊĊČČĎĎĐĐĒĒĔĔĖĖĘĘĚĚĜĜĞĞĠĠĢĢĤĤĦĦĨĨĪĪĬĬĮĮ"), + stringToRunes("ĀĀĂĂĄĄĆĆĈĈĊĊČČĎĎĐĐĒĒĔĔĖĖĘĘĚĚĜĜĞĞĠĠĢĢĤĤĦĦĨĨĪĪĬĬĮĮ"), ], [ [], new UnicodeRangeTable( new Uint32Array([codePoint("Ā") + 1, codePoint("Į") + 1, 2]), ), - Utils.stringToRunes("āāăăąąććĉĉċċččďďđđēēĕĕėėęęěěĝĝğğġġģģĥĥħħĩĩīīĭĭįį"), + stringToRunes("āāăăąąććĉĉċċččďďđđēēĕĕėėęęěěĝĝğğġġģģĥĥħħĩĩīīĭĭįį"), ], ]; @@ -278,7 +278,7 @@ describe(".appendNegatedTable", () => { ), ) .toArray(), - [0, codePoint("a"), codePoint("g"), Unicode.MAX_RUNE], + [0, codePoint("a"), codePoint("g"), MAX_RUNE], ); }); }); @@ -289,7 +289,7 @@ describe(".appendGroup", () => { [ [], getPerlGroups().get("\\D")!, - [0, codePoint("/"), codePoint(":"), Unicode.MAX_RUNE], + [0, codePoint("/"), codePoint(":"), MAX_RUNE], ], ]; diff --git a/packages/re2/src/__tests__/DFA.test.ts b/packages/re2/src/__tests__/DFA.test.ts index db2168e..e29f931 100644 --- a/packages/re2/src/__tests__/DFA.test.ts +++ b/packages/re2/src/__tests__/DFA.test.ts @@ -3,10 +3,16 @@ import * as assert from "node:assert/strict"; import { DFA } from "../DFA.js"; import { Compiler } from "../Compiler.js"; import { Parser } from "../Parser.js"; -import { RE2Flags } from "../RE2Flags.js"; +import { + ANCHOR_BOTH, + ANCHOR_START, + FOLD_CASE, + PERL, + UNANCHORED, +} from "../RE2Flags.js"; import { fromUTF16 } from "../MachineInput.js"; -const createDFA = (pattern: string, flags: number = RE2Flags.PERL): DFA => { +const createDFA = (pattern: string, flags: number = PERL): DFA => { const re = Parser.parse(pattern, flags); const prog = Compiler.compileRegexp(re); return new DFA(prog); @@ -15,7 +21,7 @@ const createDFA = (pattern: string, flags: number = RE2Flags.PERL): DFA => { const runDFA = ( dfa: DFA, text: string, - anchor: number = RE2Flags.UNANCHORED, + anchor: number = UNANCHORED, ): boolean | null => { const input = fromUTF16(text); return dfa.match(input, 0, anchor); @@ -46,11 +52,11 @@ describe("DFA", () => { describe("Anchored Matching", () => { const cases: [string, string, number, boolean][] = [ - ["abc", "abc", RE2Flags.ANCHOR_BOTH, true], - ["abc", "xabcy", RE2Flags.ANCHOR_BOTH, false], - ["abc", "abcxyz", RE2Flags.ANCHOR_START, true], - ["abc", "xyzabc", RE2Flags.ANCHOR_START, false], - ["abc", "xyzabc", RE2Flags.UNANCHORED, true], + ["abc", "abc", ANCHOR_BOTH, true], + ["abc", "xabcy", ANCHOR_BOTH, false], + ["abc", "abcxyz", ANCHOR_START, true], + ["abc", "xyzabc", ANCHOR_START, false], + ["abc", "xyzabc", UNANCHORED, true], ]; for (const [pattern, text, anchor, expected] of cases) { @@ -70,7 +76,7 @@ describe("DFA", () => { for (const [pattern, text, expected] of cases) { test(`pattern ${JSON.stringify(pattern)} with input ${JSON.stringify(text)} returns ${expected}`, () => { - const dfa = createDFA(pattern, RE2Flags.PERL | RE2Flags.FOLD_CASE); + const dfa = createDFA(pattern, PERL | FOLD_CASE); assert.strictEqual(runDFA(dfa, text), expected); }); } diff --git a/packages/re2/src/__tests__/Exec.test.ts b/packages/re2/src/__tests__/Exec.test.ts index eddb299..fc28198 100644 --- a/packages/re2/src/__tests__/Exec.test.ts +++ b/packages/re2/src/__tests__/Exec.test.ts @@ -7,8 +7,8 @@ import readline from "node:readline"; import url from "node:url"; import { RE2 } from "../RE2.js"; -import { RE2Flags } from "../RE2Flags.js"; -import { Utils } from "../Utils.js"; +import { CLASS_NL, FOLD_CASE, POSIX } from "../RE2Flags.js"; +import { quoteMeta } from "../Utils.js"; const FIXTURES_DIRNAME = path.join( path.dirname(url.fileURLToPath(import.meta.url)), @@ -360,18 +360,18 @@ const testFowler = async (fileName: string): Promise => { for (let i = 0; i < flag.length; i++) { let pattern = field[1]; - let flags = RE2Flags.POSIX | RE2Flags.CLASS_NL; + let flags = POSIX | CLASS_NL; switch (flag.charAt(i)) { default: continue; case "E": break; case "L": - pattern = Utils.quoteMeta(pattern); + pattern = quoteMeta(pattern); } if (flag.indexOf("i") >= 0) { - flags |= RE2Flags.FOLD_CASE; + flags |= FOLD_CASE; } let re = null; diff --git a/packages/re2/src/__tests__/Inst.test.ts b/packages/re2/src/__tests__/Inst.test.ts index bcab682..bb2e351 100644 --- a/packages/re2/src/__tests__/Inst.test.ts +++ b/packages/re2/src/__tests__/Inst.test.ts @@ -1,7 +1,7 @@ import { describe, it } from "node:test"; import * as assert from "node:assert/strict"; import { Inst } from "../Inst.js"; -import { RE2Flags } from "../RE2Flags.js"; +import { FOLD_CASE } from "../RE2Flags.js"; describe("Inst.matchRune Array Search Logic", () => { it("correctly matches using the linear search fast-path (length 4)", () => { @@ -40,7 +40,7 @@ describe("Inst.matchRune Array Search Logic", () => { it("correctly handles case-folding single runes", () => { const inst = new Inst(Inst.RUNE); inst.runes = ["a".codePointAt(0)!]; - inst.arg = RE2Flags.FOLD_CASE; + inst.arg = FOLD_CASE; assert.strictEqual(inst.matchRune("a".codePointAt(0)!), true); assert.strictEqual(inst.matchRune("A".codePointAt(0)!), true); diff --git a/packages/re2/src/__tests__/Parser.test.ts b/packages/re2/src/__tests__/Parser.test.ts index 9a0b7e2..06c3882 100644 --- a/packages/re2/src/__tests__/Parser.test.ts +++ b/packages/re2/src/__tests__/Parser.test.ts @@ -1,9 +1,17 @@ import { describe, test, it } from "node:test"; import * as assert from "node:assert/strict"; -import { RE2Flags } from "../RE2Flags.js"; +import { + FOLD_CASE, + LITERAL, + MATCH_NL, + PERL, + PERL_X, + POSIX, + UNICODE_GROUPS, +} from "../RE2Flags.js"; import { RE2JSSyntaxException } from "../exceptions.js"; import { Parser } from "../Parser.js"; -import { Unicode } from "../Unicode.js"; +import { isUpper, simpleFold } from "../Unicode.js"; import { dumpRegexp, mkCharClass } from "../__utils__/parser.js"; describe(".parse", () => { @@ -110,21 +118,17 @@ describe(".parse", () => { "[\\pZ]", "cc{0x20 0xa0 0x1680 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}", ], - ["\\p{Lu}", mkCharClass((r) => Unicode.isUpper(r))], - ["[\\p{Lu}]", mkCharClass((r) => Unicode.isUpper(r))], + ["\\p{Lu}", mkCharClass((r) => isUpper(r))], + ["[\\p{Lu}]", mkCharClass((r) => isUpper(r))], [ "(?i)[\\p{Lu}]", mkCharClass((r) => { - if (Unicode.isUpper(r)) { + if (isUpper(r)) { return true; } - for ( - let c = Unicode.simpleFold(r); - c !== r; - c = Unicode.simpleFold(c) - ) { - if (Unicode.isUpper(c)) { + for (let c = simpleFold(r); c !== r; c = simpleFold(c)) { + if (isUpper(c)) { return true; } } @@ -229,7 +233,7 @@ describe(".parse", () => { [`(${[...new Array(12345)].map(() => "|").join("")})`, null], ]; - const flags = RE2Flags.MATCH_NL | RE2Flags.PERL_X | RE2Flags.UNICODE_GROUPS; + const flags = MATCH_NL | PERL_X | UNICODE_GROUPS; for (const [input, expected] of cases) { test(`input ${JSON.stringify(input).slice(0, 100)} returns ${JSON.stringify(expected)}`, () => { @@ -257,7 +261,7 @@ describe("fold cases", () => { for (const [input, expected] of cases) { test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { - const re = Parser.parse(input, RE2Flags.FOLD_CASE); + const re = Parser.parse(input, FOLD_CASE); assert.strictEqual(dumpRegexp(re), expected); }); } @@ -270,7 +274,7 @@ describe("literal cases", () => { for (const [input, expected] of cases) { test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { - const re = Parser.parse(input, RE2Flags.LITERAL); + const re = Parser.parse(input, LITERAL); assert.strictEqual(dumpRegexp(re), expected); }); } @@ -286,7 +290,7 @@ describe("match new line cases", () => { for (const [input, expected] of cases) { test(`input ${JSON.stringify(input)} expected ${JSON.stringify(expected)}`, () => { - const re = Parser.parse(input, RE2Flags.MATCH_NL); + const re = Parser.parse(input, MATCH_NL); assert.strictEqual(dumpRegexp(re), expected); }); } @@ -356,14 +360,8 @@ describe("invalid regexp cases", () => { for (const input of invalidInputs) { test(`invalid ${JSON.stringify(input).slice(0, 80)} raise error`, () => { - assert.throws( - () => Parser.parse(input, RE2Flags.PERL), - RE2JSSyntaxException, - ); - assert.throws( - () => Parser.parse(input, RE2Flags.POSIX), - RE2JSSyntaxException, - ); + assert.throws(() => Parser.parse(input, PERL), RE2JSSyntaxException); + assert.throws(() => Parser.parse(input, POSIX), RE2JSSyntaxException); }); } @@ -382,7 +380,7 @@ describe("invalid regexp cases", () => { for (const input of validInPerl) { test(`valid ${JSON.stringify(input)} in perl mode`, () => { - assert.doesNotThrow(() => Parser.parse(input, RE2Flags.PERL)); + assert.doesNotThrow(() => Parser.parse(input, PERL)); }); } @@ -397,10 +395,7 @@ describe("invalid regexp cases", () => { for (const input of invalidInPerl) { test(`invalid ${JSON.stringify(input)} in perl mode`, () => { - assert.throws( - () => Parser.parse(input, RE2Flags.PERL), - RE2JSSyntaxException, - ); + assert.throws(() => Parser.parse(input, PERL), RE2JSSyntaxException); }); } }); @@ -409,21 +404,21 @@ describe("large AST flat structures", () => { it("should not exceed call stack size on massive alternations", () => { const massiveAlternation = new Array(100000).fill("a").join("|"); assert.doesNotThrow(() => { - Parser.parse(massiveAlternation, RE2Flags.PERL); + Parser.parse(massiveAlternation, PERL); }); }); it("should not exceed call stack size on massive concatenations", () => { const massiveConcat = new Array(100000).fill("(a)").join(""); assert.doesNotThrow(() => { - Parser.parse(massiveConcat, RE2Flags.PERL); + Parser.parse(massiveConcat, PERL); }); }); }); describe("Flag interactions", () => { it("should parse \\p correctly with UNICODE_GROUPS enabled", () => { - const re = Parser.parse("\\p{Any}", RE2Flags.PERL); + const re = Parser.parse("\\p{Any}", PERL); assert.strictEqual(dumpRegexp(re), "dot{}"); }); }); diff --git a/packages/re2/src/__tests__/Prefilter.test.ts b/packages/re2/src/__tests__/Prefilter.test.ts index 78a182b..de552be 100644 --- a/packages/re2/src/__tests__/Prefilter.test.ts +++ b/packages/re2/src/__tests__/Prefilter.test.ts @@ -1,9 +1,9 @@ import { describe, test, it } from "node:test"; import * as assert from "node:assert/strict"; import { Parser } from "../Parser.js"; -import { Simplify } from "../Simplify.js"; +import { simplify } from "../Simplify.js"; import { PrefilterTree, Prefilter } from "../Prefilter.js"; -import { RE2Flags } from "../RE2Flags.js"; +import { PERL } from "../RE2Flags.js"; import { RE2JS } from "../index.js"; import { fromUTF16 } from "../MachineInput.js"; @@ -23,12 +23,9 @@ const dumpPrefilter = (pf: Prefilter | null): string => { } }; -const getPrefilterDump = ( - pattern: string, - flags: number = RE2Flags.PERL, -): string => { +const getPrefilterDump = (pattern: string, flags: number = PERL): string => { let re = Parser.parse(pattern, flags); - re = Simplify.simplify(re); + re = simplify(re); const pf = PrefilterTree.build(re); return dumpPrefilter(pf); }; @@ -77,18 +74,14 @@ describe("PrefilterTree.build AST Extraction", () => { describe("Prefilter Evaluation (UTF-16 & UTF-8)", () => { it("correctly evaluates EXACT filters", () => { - const pf = PrefilterTree.build( - Simplify.simplify(Parser.parse("foo", RE2Flags.PERL)), - ); + const pf = PrefilterTree.build(simplify(Parser.parse("foo", PERL))); assert.strictEqual(pf.eval(fromUTF16("bar foo baz"), 0), true); assert.strictEqual(pf.eval(fromUTF16("bar fox baz"), 0), false); }); it("correctly evaluates AND filters", () => { - const pf = PrefilterTree.build( - Simplify.simplify(Parser.parse("foo.*bar", RE2Flags.PERL)), - ); + const pf = PrefilterTree.build(simplify(Parser.parse("foo.*bar", PERL))); const input1 = fromUTF16("foo and then bar"); assert.strictEqual(pf.eval(input1, 0), true); @@ -98,9 +91,7 @@ describe("Prefilter Evaluation (UTF-16 & UTF-8)", () => { }); it("correctly evaluates OR filters", () => { - const pf = PrefilterTree.build( - Simplify.simplify(Parser.parse("foo|bar", RE2Flags.PERL)), - ); + const pf = PrefilterTree.build(simplify(Parser.parse("foo|bar", PERL))); const input1 = fromUTF16("I have a bar"); assert.strictEqual(pf.eval(input1, 0), true); @@ -129,7 +120,7 @@ describe("Engine Integration", () => { describe("Advanced Prefilter Evaluation", () => { it("handles complex AND/OR logic branches correctly", () => { const pf = PrefilterTree.build( - Simplify.simplify(Parser.parse("(foo|bar)baz", RE2Flags.PERL)), + simplify(Parser.parse("(foo|bar)baz", PERL)), ); assert.strictEqual(pf.eval(fromUTF16("foobaz"), 0), true); @@ -140,9 +131,7 @@ describe("Advanced Prefilter Evaluation", () => { }); it("evaluates emojis and multi-byte unicode safely", () => { - const pf = PrefilterTree.build( - Simplify.simplify(Parser.parse("🚀.*🌕", RE2Flags.PERL)), - ); + const pf = PrefilterTree.build(simplify(Parser.parse("🚀.*🌕", PERL))); assert.strictEqual(pf.eval(fromUTF16("To the 🚀 and then 🌕!"), 0), true); assert.strictEqual( @@ -152,9 +141,7 @@ describe("Advanced Prefilter Evaluation", () => { }); it("respects end boundaries on bounded input buffers", () => { - const pf = PrefilterTree.build( - Simplify.simplify(Parser.parse("hidden", RE2Flags.PERL)), - ); + const pf = PrefilterTree.build(simplify(Parser.parse("hidden", PERL))); const text = "visible hidden"; const utf16Input = fromUTF16(text, 0, 7); diff --git a/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts b/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts index df21ee4..cd155a0 100644 --- a/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts +++ b/packages/re2/src/__tests__/RE2ExecuteEngine.test.ts @@ -2,7 +2,7 @@ import { describe, test } from "node:test"; import * as assert from "node:assert/strict"; import { RE2 } from "../RE2.js"; import { DFA } from "../DFA.js"; -import { RE2Flags } from "../RE2Flags.js"; +import { ANCHOR_BOTH } from "../RE2Flags.js"; import { fromUTF16 } from "../MachineInput.js"; import { Prefilter } from "../Prefilter.js"; @@ -32,19 +32,19 @@ describe("Literal Fast-Path Routing", () => { const matchInput = fromUTF16("hello"); assert.notStrictEqual( - re.executeEngine(matchInput, 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(matchInput, 0, ANCHOR_BOTH, 0), null, ); const noMatchInput1 = fromUTF16("hello world"); assert.strictEqual( - re.executeEngine(noMatchInput1, 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(noMatchInput1, 0, ANCHOR_BOTH, 0), null, ); const noMatchInput2 = fromUTF16("say hello"); assert.strictEqual( - re.executeEngine(noMatchInput2, 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(noMatchInput2, 0, ANCHOR_BOTH, 0), null, ); diff --git a/packages/re2/src/__tests__/RE2QuoteMeta.test.ts b/packages/re2/src/__tests__/RE2QuoteMeta.test.ts index be69aec..25bcaac 100644 --- a/packages/re2/src/__tests__/RE2QuoteMeta.test.ts +++ b/packages/re2/src/__tests__/RE2QuoteMeta.test.ts @@ -2,7 +2,7 @@ import { describe, test } from "node:test"; import * as assert from "node:assert/strict"; import { RE2 } from "../RE2.js"; import { RE2JS } from "../index.js"; -import { Utils } from "../Utils.js"; +import { quoteMeta } from "../Utils.js"; const cases: [string, string, string, boolean][] = [ ["", "", "", true], @@ -20,8 +20,8 @@ const cases: [string, string, string, boolean][] = [ describe("quoteMeta", () => { for (const [pattern, output] of cases) { test(`quote meta: pattern ${JSON.stringify(pattern)} quoted to ${JSON.stringify(output)}`, () => { - const quoted = Utils.quoteMeta(pattern); - assert.strictEqual(Utils.quoteMeta(pattern), output); + const quoted = quoteMeta(pattern); + assert.strictEqual(quoteMeta(pattern), output); assert.strictEqual(RE2JS.quote(pattern), output); if (pattern && pattern.length > 0) { const re = RE2.compile(quoted); diff --git a/packages/re2/src/__tests__/Unicode.test.ts b/packages/re2/src/__tests__/Unicode.test.ts index a58cc7a..57bc1dd 100644 --- a/packages/re2/src/__tests__/Unicode.test.ts +++ b/packages/re2/src/__tests__/Unicode.test.ts @@ -1,6 +1,6 @@ import { describe, test, it } from "node:test"; import * as assert from "node:assert/strict"; -import { Unicode } from "../Unicode.js"; +import { equalsIgnoreCase, isUpper, simpleFold } from "../Unicode.js"; import { UnicodeTables } from "../UnicodeTables.js"; import { codePoint } from "../__utils__/chars.js"; @@ -16,7 +16,7 @@ describe("#isUpper", () => { for (const [input, expected] of cases) { test(`#isUpper(${input}) === ${expected}`, () => { - assert.strictEqual(Unicode.isUpper(input), expected); + assert.strictEqual(isUpper(input), expected); }); } }); @@ -37,7 +37,7 @@ describe("#simpleFold", () => { for (const [input, expected] of cases) { test(`#simpleFold(${input}) === ${expected}`, () => { - assert.strictEqual(Unicode.simpleFold(input), expected); + assert.strictEqual(simpleFold(input), expected); }); } }); @@ -69,7 +69,7 @@ const genEqualsIgnoreCases = (): [number, number, boolean][] => { describe("#equalsIgnoreCase", () => { for (const [r1, r2, expected] of genEqualsIgnoreCases()) { test(`#equalsIgnoreCase(${r1}, ${r2}) === ${expected}`, () => { - assert.strictEqual(Unicode.equalsIgnoreCase(r1, r2), expected); + assert.strictEqual(equalsIgnoreCase(r1, r2), expected); }); } }); diff --git a/packages/re2/src/__tests__/edge-cases.test.ts b/packages/re2/src/__tests__/edge-cases.test.ts index f2f9db6..1e4e180 100644 --- a/packages/re2/src/__tests__/edge-cases.test.ts +++ b/packages/re2/src/__tests__/edge-cases.test.ts @@ -3,7 +3,7 @@ import * as assert from "node:assert/strict"; import { RE2JS } from "../index.js"; import { RE2 } from "../RE2.js"; import { fromUTF16 } from "../MachineInput.js"; -import { RE2Flags } from "../RE2Flags.js"; +import { ANCHOR_BOTH, ANCHOR_START, UNANCHORED } from "../RE2Flags.js"; describe("Edge cases and bug hunting", () => { describe("Empty patterns and inputs", () => { @@ -174,11 +174,11 @@ describe("Edge cases and bug hunting", () => { it("ANCHOR_START from pos 0 only matches if the pattern starts at 0", () => { const re = RE2.compile("abc"); assert.notStrictEqual( - re.executeEngine(fromUTF16("abcxyz"), 0, RE2Flags.ANCHOR_START, 0), + re.executeEngine(fromUTF16("abcxyz"), 0, ANCHOR_START, 0), null, ); assert.strictEqual( - re.executeEngine(fromUTF16("xabc"), 0, RE2Flags.ANCHOR_START, 0), + re.executeEngine(fromUTF16("xabc"), 0, ANCHOR_START, 0), null, ); }); @@ -186,15 +186,15 @@ describe("Edge cases and bug hunting", () => { it("ANCHOR_BOTH requires exact full-input match", () => { const re = RE2.compile("abc"); assert.notStrictEqual( - re.executeEngine(fromUTF16("abc"), 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(fromUTF16("abc"), 0, ANCHOR_BOTH, 0), null, ); assert.strictEqual( - re.executeEngine(fromUTF16("abcd"), 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(fromUTF16("abcd"), 0, ANCHOR_BOTH, 0), null, ); assert.strictEqual( - re.executeEngine(fromUTF16("xabc"), 0, RE2Flags.ANCHOR_BOTH, 0), + re.executeEngine(fromUTF16("xabc"), 0, ANCHOR_BOTH, 0), null, ); }); @@ -202,44 +202,14 @@ describe("Edge cases and bug hunting", () => { it("DFA and NFA agree on all anchor modes", () => { const re = RE2.compile("abc"); const inputStr = "xabcy"; - const dfaUA = re.executeEngine( - fromUTF16(inputStr), - 0, - RE2Flags.UNANCHORED, - 0, - ); - const dfaAS = re.executeEngine( - fromUTF16(inputStr), - 0, - RE2Flags.ANCHOR_START, - 0, - ); - const dfaAB = re.executeEngine( - fromUTF16(inputStr), - 0, - RE2Flags.ANCHOR_BOTH, - 0, - ); + const dfaUA = re.executeEngine(fromUTF16(inputStr), 0, UNANCHORED, 0); + const dfaAS = re.executeEngine(fromUTF16(inputStr), 0, ANCHOR_START, 0); + const dfaAB = re.executeEngine(fromUTF16(inputStr), 0, ANCHOR_BOTH, 0); re.dfa.failed = true; - const nfaUA = re.executeEngine( - fromUTF16(inputStr), - 0, - RE2Flags.UNANCHORED, - 0, - ); - const nfaAS = re.executeEngine( - fromUTF16(inputStr), - 0, - RE2Flags.ANCHOR_START, - 0, - ); - const nfaAB = re.executeEngine( - fromUTF16(inputStr), - 0, - RE2Flags.ANCHOR_BOTH, - 0, - ); + const nfaUA = re.executeEngine(fromUTF16(inputStr), 0, UNANCHORED, 0); + const nfaAS = re.executeEngine(fromUTF16(inputStr), 0, ANCHOR_START, 0); + const nfaAB = re.executeEngine(fromUTF16(inputStr), 0, ANCHOR_BOTH, 0); assert.strictEqual(Boolean(nfaUA), Boolean(dfaUA)); assert.strictEqual(Boolean(nfaAS), Boolean(dfaAS)); @@ -475,7 +445,6 @@ describe("Edge cases and bug hunting", () => { it("(?...) Perl-style named group is also accepted", () => { const re = RE2JS.compile("(?\\w+)"); assert.strictEqual(re.test("hello"), true); - console.log(re.namedGroups()); assert.deepStrictEqual( re.namedGroups(), new Map().set("word", 1), diff --git a/packages/re2/src/__utils__/parser.ts b/packages/re2/src/__utils__/parser.ts index 52b8182..5748677 100644 --- a/packages/re2/src/__utils__/parser.ts +++ b/packages/re2/src/__utils__/parser.ts @@ -1,6 +1,6 @@ -import { RE2Flags } from "../RE2Flags.js"; +import { FOLD_CASE, NON_GREEDY, WAS_DOLLAR } from "../RE2Flags.js"; import { Regexp } from "../Regexp.js"; -import { Unicode } from "../Unicode.js"; +import { MAX_RUNE, simpleFold } from "../Unicode.js"; const OP_NAMES = new Map([ [Regexp.Op.NO_MATCH, "no"], @@ -36,7 +36,7 @@ export const dumpRegexp = (re: Regexp): string => { case Regexp.Op.PLUS: case Regexp.Op.QUEST: case Regexp.Op.REPEAT: - if ((re.flags & RE2Flags.NON_GREEDY) !== 0) { + if ((re.flags & NON_GREEDY) !== 0) { b += "n"; } b += name; @@ -47,9 +47,9 @@ export const dumpRegexp = (re: Regexp): string => { } else { b += "lit"; } - if ((re.flags & RE2Flags.FOLD_CASE) !== 0) { + if ((re.flags & FOLD_CASE) !== 0) { for (let r of re.runes) { - if (Unicode.simpleFold(r) !== r) { + if (simpleFold(r) !== r) { b += "fold"; break; } @@ -64,7 +64,7 @@ export const dumpRegexp = (re: Regexp): string => { b += "{"; switch (re.op) { case Regexp.Op.END_TEXT: - if ((re.flags & RE2Flags.WAS_DOLLAR) === 0) { + if ((re.flags & WAS_DOLLAR) === 0) { b += "\\z"; } break; @@ -121,7 +121,7 @@ export const mkCharClass = (f: (r: number) => boolean): string => { let runes: number[] = []; let lo = -1; - for (let i = 0; i <= Unicode.MAX_RUNE; i++) { + for (let i = 0; i <= MAX_RUNE; i++) { if (f(i)) { if (lo < 0) { lo = i; @@ -132,7 +132,7 @@ export const mkCharClass = (f: (r: number) => boolean): string => { } } if (lo >= 0) { - runes = [...runes, lo, Unicode.MAX_RUNE]; + runes = [...runes, lo, MAX_RUNE]; } re.runes = runes; diff --git a/packages/re2/src/index.ts b/packages/re2/src/index.ts index 28d5b37..32b2c5d 100644 --- a/packages/re2/src/index.ts +++ b/packages/re2/src/index.ts @@ -1,7 +1,7 @@ -import { RE2Flags } from "./RE2Flags.js"; +import { ANCHOR_BOTH, PERL, UNICODE_GROUPS } from "./RE2Flags.js"; import { fromUTF16 } from "./MachineInput.js"; import { RE2 } from "./RE2.js"; -import { Utils } from "./Utils.js"; +import { quoteMeta } from "./Utils.js"; import { RE2JSCompileException, RE2JSException, @@ -46,7 +46,7 @@ class RE2JS { * @returns {string} A literal string replacement */ static quote(str: string): string { - return Utils.quoteMeta(str); + return quoteMeta(str); } /** @@ -107,9 +107,9 @@ class RE2JS { * @param {number} flags */ constructor(pattern: string, flags = 0) { - let re2Flags = RE2Flags.PERL; + let re2Flags = PERL; if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) { - re2Flags &= ~RE2Flags.UNICODE_GROUPS; + re2Flags &= ~UNICODE_GROUPS; } RE2JS.validateFlags(flags); const fregex = RE2JS.buildRegexWithFlags(pattern, flags); @@ -174,12 +174,7 @@ class RE2JS { */ testExact(input: string): boolean { return ( - this.re2Input.executeEngine( - fromUTF16(input), - 0, - RE2Flags.ANCHOR_BOTH, - 0, - ) !== null + this.re2Input.executeEngine(fromUTF16(input), 0, ANCHOR_BOTH, 0) !== null ); } From 100f4db05100fbcba8bc621213cecbb025d1221b Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Mon, 20 Apr 2026 16:39:28 -0400 Subject: [PATCH 07/13] finish lint changes --- packages/re2/scripts/genUnicodeTable.js | 283 ++-- packages/re2/src/CharClass.ts | 10 +- packages/re2/src/Compiler.ts | 13 +- packages/re2/src/DFA.ts | 19 +- packages/re2/src/Parser.ts | 139 +- packages/re2/src/Prefilter.ts | 209 ++- packages/re2/src/RE2.ts | 10 +- packages/re2/src/Unicode.ts | 16 +- packages/re2/src/UnicodeTables.ts | 1242 ++++++++++++------ packages/re2/src/Utils.ts | 3 +- packages/re2/src/__tests__/BugHunt.test.ts | 14 +- packages/re2/src/__tests__/CharClass.test.ts | 18 +- packages/re2/src/__tests__/Exec.test.ts | 29 +- packages/re2/src/__tests__/Inst.test.ts | 9 +- packages/re2/src/__tests__/Unicode.test.ts | 9 +- packages/re2/src/__tests__/index.test.ts | 8 +- packages/re2/src/__tests__/stability.test.ts | 2 +- packages/re2/src/__utils__/chars.ts | 18 +- packages/re2/src/__utils__/parser.ts | 2 +- 19 files changed, 1250 insertions(+), 803 deletions(-) diff --git a/packages/re2/scripts/genUnicodeTable.js b/packages/re2/scripts/genUnicodeTable.js index 98d6f25..52c650d 100644 --- a/packages/re2/scripts/genUnicodeTable.js +++ b/packages/re2/scripts/genUnicodeTable.js @@ -1,6 +1,5 @@ import { CodepointRange } from "./codepointRange.js"; import unicode16 from "@unicode/unicode-16.0.0"; -import unicode15 from "@unicode/unicode-15.0.0"; import CommonCaseFolding from "@unicode/unicode-16.0.0/Case_Folding/C/code-points.js"; import SimpleCaseFolding from "@unicode/unicode-16.0.0/Case_Folding/S/code-points.js"; import unicodePropertyValueAliases from "unicode-property-value-aliases"; @@ -170,7 +169,7 @@ for (const [alias, name] of aliasesToNames.entries()) { } } -for (const name of unicode16["Script"]) { +for (const name of unicode16.Script) { const cp16 = await loadCodePoints("@unicode/unicode-16.0.0", "Script", name); if (!cp16) continue; const cp15 = await loadCodePoints("@unicode/unicode-15.0.0", "Script", name); @@ -213,7 +212,7 @@ const code = [ "// GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT.", "// yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts", "", - "import { UnicodeRangeTable } from './UnicodeRangeTable'", + "import { UnicodeRangeTable } from './UnicodeRangeTable.js'", "", "let _B64_MAP: Uint8Array | null = null", "const getB64Map = (): Uint8Array => {", @@ -337,7 +336,10 @@ const code = [ " }", " has(key: string): boolean { return key in this.initializer }", " get(key: string): V | null {", - " if (this.cache.has(key)) return this.cache.get(key)!", + " const cached = this.cache.get(key)", + " if (cached !== undefined || this.cache.has(key)) {", + " return cached ?? null", + " }", " const fn = this.initializer[key]", " const val = fn ? fn() : null", " this.cache.set(key, val)", @@ -345,164 +347,173 @@ const code = [ " }", "}", "", - "class UnicodeTables {", - " private static _CASE_ORBIT: Map | null = null", - " static get CASE_ORBIT(): Map {", - " if (!this._CASE_ORBIT) {", - ` this._CASE_ORBIT = decodeOrbit('${orbitEnc}')`, - " }", - " return this._CASE_ORBIT", + "let _CASE_ORBIT: Map | null = null", + "const getCASE_ORBIT = (): Map => {", + " if (!_CASE_ORBIT) {", + ` _CASE_ORBIT = decodeOrbit('${orbitEnc}')`, " }", + " return _CASE_ORBIT", + "}", "", - " // Additions from Unicode 15.0 → 16.0 per stable general-category name.", - " // Merged unconditionally with platform sweep output; no-op on 16.0+ engines.", - " private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({", + "// Additions from Unicode 15.0 → 16.0 per stable general-category name.", + "// Merged unconditionally with platform sweep output; no-op on 16.0+ engines.", + "const _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({", ...deltaCatLines, - " })", + "})", "", - " // Additions from Unicode 15.0 → 16.0 per stable script name.", - " private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({", + "// Additions from Unicode 15.0 → 16.0 per stable script name.", + "const _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({", ...deltaScrLines, - " })", + "})", "", - " // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw", - " // SyntaxError on these names, so platform sweep is impossible.", - " private static _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({", + "// Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw", + "// SyntaxError on these names, so platform sweep is impossible.", + "const _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({", ...newScriptLines, - " })", + "})", "", - ` static readonly STABLE_CATEGORY_NAMES: ReadonlySet = new Set(${JSON.stringify(stableCategoryNames)})`, - ` static readonly STABLE_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(stableScriptNames)})`, - ` static readonly NEW_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(newScriptNames)})`, + `const STABLE_CATEGORY_NAMES: ReadonlySet = new Set(${JSON.stringify(stableCategoryNames)})`, + `const STABLE_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(stableScriptNames)})`, + `const NEW_SCRIPT_NAMES: ReadonlySet = new Set(${JSON.stringify(newScriptNames)})`, "", - " private static _sweepCache = new Map()", - " private static _foldCache = new Map()", + "const _sweepCache = new Map()", + "const _foldCache = new Map()", "", - " // Returns the base range table for a property name, or null if unknown.", - " // Stable names: platform sweep + bundled delta (15.0 → 16.0).", - " // New-in-16.0 script names: bundled full table.", - " static buildForProperty(name: string): UnicodeRangeTable | null {", - " if (this.NEW_SCRIPT_NAMES.has(name)) {", - " return this._NEW_SCRIPTS.get(name)", - " }", - ' let kind: "category" | "script" | null = null', - " let pattern: string | null = null", - ' if (this.STABLE_CATEGORY_NAMES.has(name)) { kind = "category"; pattern = `\\\\p{General_Category=${name}}` }', - ' else if (this.STABLE_SCRIPT_NAMES.has(name)) { kind = "script"; pattern = `\\\\p{Script=${name}}` }', - " else return null", + "// Returns the base range table for a property name, or null if unknown.", + "// Stable names: platform sweep + bundled delta (15.0 → 16.0).", + "// New-in-16.0 script names: bundled full table.", + "const buildForProperty = (name: string): UnicodeRangeTable | null => {", + " if (NEW_SCRIPT_NAMES.has(name)) {", + " return _NEW_SCRIPTS.get(name)", + " }", + ' let kind: "category" | "script" | null = null', + " let pattern: string | null = null", + ' if (STABLE_CATEGORY_NAMES.has(name)) { kind = "category"; pattern = `\\\\p{General_Category=${name}}` }', + ' else if (STABLE_SCRIPT_NAMES.has(name)) { kind = "script"; pattern = `\\\\p{Script=${name}}` }', + " else return null", "", - " const cacheKey = `${kind}:${name}`", - " const cached = this._sweepCache.get(cacheKey)", - " if (cached) return cached", + " const cacheKey = `${kind}:${name}`", + " const cached = _sweepCache.get(cacheKey)", + " if (cached) return cached", "", - " const base = sweepPlatform(pattern)", - ' const delta = kind === "category" ? this._DELTA_CATEGORIES.get(name) : this._DELTA_SCRIPTS.get(name)', - " const merged = delta ? mergeRanges(base, delta) : base", - " const table = new UnicodeRangeTable(merged)", - " this._sweepCache.set(cacheKey, table)", - " return table", - " }", + " const base = sweepPlatform(pattern)", + ' const delta = kind === "category" ? _DELTA_CATEGORIES.get(name) : _DELTA_SCRIPTS.get(name)', + " const merged = delta ? mergeRanges(base, delta) : base", + " const table = new UnicodeRangeTable(merged)", + " _sweepCache.set(cacheKey, table)", + " return table", + "}", "", - " // Computes the fold-overlay for a property name: additional runes that", - " // fold to some rune already in the base class. Returns null if no overlay", - " // is needed (base class is fold-stable).", - " static buildFoldOverlay(name: string): UnicodeRangeTable | null {", - " const cached = this._foldCache.get(name)", - " if (cached !== undefined) return cached", - " const base = this.buildForProperty(name)", - " if (!base) {", - " this._foldCache.set(name, null)", - " return null", + "// Computes the fold-overlay for a property name: additional runes that", + "// fold to some rune already in the base class. Returns null if no overlay", + "// is needed (base class is fold-stable).", + "const buildFoldOverlay = (name: string): UnicodeRangeTable | null => {", + " const cached = _foldCache.get(name)", + " if (cached !== undefined) return cached", + " const base = buildForProperty(name)", + " if (!base) {", + " _foldCache.set(name, null)", + " return null", + " }", + " const inBase = (r: number): boolean => {", + " let lo = 0, hi = base.length", + " while (lo < hi) {", + " const m = (lo + hi) >> 1", + " const rlo = base.getLo(m), rhi = base.getHi(m)", + " if (r < rlo) hi = m", + " else if (r > rhi) lo = m + 1", + " else return ((r - rlo) % base.getStride(m)) === 0", " }", - " const inBase = (r: number): boolean => {", - " let lo = 0, hi = base.length", - " while (lo < hi) {", - " const m = (lo + hi) >> 1", - " const rlo = base.getLo(m), rhi = base.getHi(m)", - " if (r < rlo) hi = m", - " else if (r > rhi) lo = m + 1", - " else return ((r - rlo) % base.getStride(m)) === 0", - " }", - " return false", + " return false", + " }", + " // Inline simpleFold to avoid circular import with Unicode.ts.", + " const orbit = getCASE_ORBIT()", + " const simpleFold = (r: number): number => {", + " const folded = orbit.get(r)", + " if (folded !== undefined) return folded", + " const s = String.fromCodePoint(r)", + " const lower = s.toLowerCase()", + " if (lower.length === s.length) {", + " const lowerCp = lower.codePointAt(0)", + " if (lowerCp !== undefined && lowerCp !== r) return lowerCp", " }", - " // Inline simpleFold to avoid circular import with Unicode.ts.", - " const orbit = UnicodeTables.CASE_ORBIT", - " const simpleFold = (r: number): number => {", - " if (orbit.has(r)) return orbit.get(r)!", - " const s = String.fromCodePoint(r)", - " const lower = s.toLowerCase()", - " if (lower.length === s.length) {", - " const lowerCp = lower.codePointAt(0)!", - " if (lowerCp !== r) return lowerCp", - " }", - " const upper = s.toUpperCase()", - " if (upper.length === s.length) {", - " const upperCp = upper.codePointAt(0)!", - " if (upperCp !== r) return upperCp", - " }", - " return r", + " const upper = s.toUpperCase()", + " if (upper.length === s.length) {", + " const upperCp = upper.codePointAt(0)", + " if (upperCp !== undefined && upperCp !== r) return upperCp", " }", - " const extras = new Set()", - " for (let i = 0; i < base.length; i++) {", - " const lo = base.getLo(i), hi = base.getHi(i), stride = base.getStride(i)", - " for (let cp = lo; cp <= hi; cp += stride) {", - " let r = simpleFold(cp)", - " while (r !== cp) {", - " if (!inBase(r)) extras.add(r)", - " r = simpleFold(r)", - " }", + " return r", + " }", + " const extras = new Set()", + " for (let i = 0; i < base.length; i++) {", + " const lo = base.getLo(i), hi = base.getHi(i), stride = base.getStride(i)", + " for (let cp = lo; cp <= hi; cp += stride) {", + " let r = simpleFold(cp)", + " while (r !== cp) {", + " if (!inBase(r)) extras.add(r)", + " r = simpleFold(r)", " }", " }", - " if (extras.size === 0) {", - " this._foldCache.set(name, null)", - " return null", - " }", - " const sorted = Array.from(extras).sort((a, b) => a - b)", - " const merged: [number, number][] = []", - " for (const cp of sorted) {", - " const last = merged[merged.length - 1]", - " if (last && last[1] + 1 === cp) last[1] = cp", - " else merged.push([cp, cp])", - " }", - " const out = new Uint32Array(merged.length * 3)", - " for (let i = 0; i < merged.length; i++) {", - " out[i * 3] = merged[i][0]", - " out[i * 3 + 1] = merged[i][1]", - " out[i * 3 + 2] = 1", - " }", - " const table = new UnicodeRangeTable(out)", - " this._foldCache.set(name, table)", - " return table", " }", - "", - " // --- Legacy API surface used by Parser ---", - "", - " static CATEGORIES = {", - " has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),", - " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)", + " if (extras.size === 0) {", + " _foldCache.set(name, null)", + " return null", " }", - "", - " static SCRIPTS = {", - " has: (name: string): boolean =>", - " UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),", - " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildForProperty(name)", + " const sorted = Array.from(extras).sort((a, b) => a - b)", + " const merged: [number, number][] = []", + " for (const cp of sorted) {", + " const last = merged[merged.length - 1]", + " if (last && last[1] + 1 === cp) last[1] = cp", + " else merged.push([cp, cp])", " }", - "", - " static FOLD_CATEGORIES = {", - " has: (name: string): boolean => UnicodeTables.STABLE_CATEGORY_NAMES.has(name),", - " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)", + " const out = new Uint32Array(merged.length * 3)", + " for (let i = 0; i < merged.length; i++) {", + " out[i * 3] = merged[i][0]", + " out[i * 3 + 1] = merged[i][1]", + " out[i * 3 + 2] = 1", " }", + " const table = new UnicodeRangeTable(out)", + " _foldCache.set(name, table)", + " return table", + "}", "", - " static FOLD_SCRIPT = {", - " has: (name: string): boolean =>", - " UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || UnicodeTables.NEW_SCRIPT_NAMES.has(name),", - " get: (name: string): UnicodeRangeTable | null => UnicodeTables.buildFoldOverlay(name)", + "const getUpper = (): UnicodeRangeTable => {", + ' const table = buildForProperty("Lu")', + " if (table === null) {", + ' throw new Error("Upper: missing Lu property")', " }", - "", - ' static get Upper(): UnicodeRangeTable { return UnicodeTables.buildForProperty("Lu")! }', + " return table", "}", "", - "export { UnicodeTables }", + "// --- Legacy API surface used by Parser ---", + "", + "export const UnicodeTables = {", + " get CASE_ORBIT(): Map { return getCASE_ORBIT() },", + " STABLE_CATEGORY_NAMES,", + " STABLE_SCRIPT_NAMES,", + " NEW_SCRIPT_NAMES,", + " buildForProperty,", + " buildFoldOverlay,", + " CATEGORIES: {", + " has: (name: string): boolean => STABLE_CATEGORY_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => buildForProperty(name),", + " },", + " SCRIPTS: {", + " has: (name: string): boolean =>", + " STABLE_SCRIPT_NAMES.has(name) || NEW_SCRIPT_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => buildForProperty(name),", + " },", + " FOLD_CATEGORIES: {", + " has: (name: string): boolean => STABLE_CATEGORY_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => buildFoldOverlay(name),", + " },", + " FOLD_SCRIPT: {", + " has: (name: string): boolean =>", + " STABLE_SCRIPT_NAMES.has(name) || NEW_SCRIPT_NAMES.has(name),", + " get: (name: string): UnicodeRangeTable | null => buildFoldOverlay(name),", + " },", + " get Upper(): UnicodeRangeTable { return getUpper() },", + "}", "", ]; diff --git a/packages/re2/src/CharClass.ts b/packages/re2/src/CharClass.ts index 27f9294..e7c99bb 100644 --- a/packages/re2/src/CharClass.ts +++ b/packages/re2/src/CharClass.ts @@ -1,6 +1,8 @@ import { FOLD_CASE } from "./RE2Flags.js"; import { MAX_FOLD, MAX_RUNE, MIN_FOLD, simpleFold } from "./Unicode.js"; import { emptyInts } from "./Utils.js"; +import type { UnicodeRangeTable } from "./UnicodeRangeTable.js"; +import type { CharGroup } from "./CharGroup.js"; /** * A "builder"-style helper class for manipulating character classes represented as an array of * pairs of runes [lo, hi], each denoting an inclusive interval. @@ -218,7 +220,7 @@ class CharClass { // appendTable() appends the Unicode range table |table| to this CharClass. // Does not mutate |table|. - appendTable(table: any): this { + appendTable(table: UnicodeRangeTable): this { for (let i = 0; i < table.length; ++i) { const lo = table.getLo(i); const hi = table.getHi(i); @@ -236,7 +238,7 @@ class CharClass { // appendNegatedTable() returns the result of appending the negation of range // table |table| to this CharClass. Does not mutate |table|. - appendNegatedTable(table: any): this { + appendNegatedTable(table: UnicodeRangeTable): this { let nextLo = 0; for (let i = 0; i < table.length; ++i) { const lo = table.getLo(i); @@ -264,7 +266,7 @@ class CharClass { // appendTableWithSign() calls append{,Negated}Table depending on sign. // Does not mutate |table|. - appendTableWithSign(table: any, sign: number): this { + appendTableWithSign(table: UnicodeRangeTable, sign: number): this { return sign < 0 ? this.appendNegatedTable(table) : this.appendTable(table); } @@ -298,7 +300,7 @@ class CharClass { // appendGroup() appends CharGroup |g| to this CharClass, folding iff // |foldCase|. Does not mutate |g|. - appendGroup(g: any, foldCase: boolean): this { + appendGroup(g: CharGroup, foldCase: boolean): this { let cls = g.cls; if (foldCase) { cls = new CharClass().appendFoldedClass(cls).cleanClass().toArray(); diff --git a/packages/re2/src/Compiler.ts b/packages/re2/src/Compiler.ts index 60f66bd..eb531d8 100644 --- a/packages/re2/src/Compiler.ts +++ b/packages/re2/src/Compiler.ts @@ -243,14 +243,13 @@ class Compiler { case Regexp.Op.LITERAL: if (re.runes.length === 0) { return this.nop(); - } else { - let f: Frag | null = null; - for (let r of re.runes) { - const f1 = this.rune([r], re.flags); - f = f === null ? f1 : this.cat(f, f1); - } - return f!; } + let f: Frag | null = null; + for (let r of re.runes) { + const f1 = this.rune([r], re.flags); + f = f === null ? f1 : this.cat(f, f1); + } + return f as Frag; case Regexp.Op.CHAR_CLASS: return this.rune(re.runes, re.flags); case Regexp.Op.ANY_CHAR_NOT_NL: diff --git a/packages/re2/src/DFA.ts b/packages/re2/src/DFA.ts index bd1d38d..f8608c9 100644 --- a/packages/re2/src/DFA.ts +++ b/packages/re2/src/DFA.ts @@ -3,6 +3,7 @@ import { UNANCHORED, ANCHOR_BOTH } from "./RE2Flags.js"; import { MAX_ASCII, MAX_RUNE } from "./Unicode.js"; import { emptyOpContext } from "./Utils.js"; import type { Prog } from "./Prog.js"; +import type { MachineUTF16Input } from "./MachineInput.js"; // FNV-1a 32-bit hash for an array of integers. const hashPCs = (pcs: Int32Array): number => { @@ -28,7 +29,7 @@ class DFAState { hasEmptyWidth: boolean; matchIDs: number[]; nextAscii: (DFAState | null)[]; - nextMap: Map; + nextMap: Map; constructor( nfaStates: Int32Array, @@ -47,7 +48,7 @@ class DFAState { class DFA { prog: Prog; - stateCache: Map; + stateCache: Map; stateCount: number; startState: DFAState | null; stateLimit: number; @@ -229,13 +230,14 @@ class DFA { context: number, ): DFAState | null { // Cache lookup - let cacheKey; + let cacheKey = 0; if (state.hasEmptyWidth) { // Context-dependent: include context in key cacheKey = charCode * 128 + (context & 0x3f) * 2 + (anchor === UNANCHORED ? 0 : 1); - if (state.nextMap.has(cacheKey)) { - return state.nextMap.get(cacheKey); + const cached = state.nextMap.get(cacheKey); + if (cached !== undefined || state.nextMap.has(cacheKey)) { + return cached ?? null; } } else { // Context-independent: use original caching @@ -246,8 +248,9 @@ class DFA { } } else { cacheKey = charCode + (anchor === UNANCHORED ? 0 : MAX_RUNE + 1); - if (state.nextMap.has(cacheKey)) { - return state.nextMap.get(cacheKey); + const cached = state.nextMap.get(cacheKey); + if (cached !== undefined || state.nextMap.has(cacheKey)) { + return cached ?? null; } } } @@ -291,7 +294,7 @@ class DFA { } // The hot loop: Execute the Lazy DFA - match(input: any, pos: number, anchor: number): boolean | null { + match(input: MachineUTF16Input, pos: number, anchor: number): boolean | null { if (!this.startState) { this.startState = this.getState([this.prog.start]); if (!this.startState) return null; diff --git a/packages/re2/src/Parser.ts b/packages/re2/src/Parser.ts index 5f2ffe8..ab9c08e 100644 --- a/packages/re2/src/Parser.ts +++ b/packages/re2/src/Parser.ts @@ -26,6 +26,7 @@ import { stringToRunes, runeToString, } from "./Utils.js"; +import { codePointAtOrThrow } from "./__utils__/chars.js"; import { CharClass } from "./CharClass.js"; import { RE2JSSyntaxException } from "./exceptions.js"; import { Regexp } from "./Regexp.js"; @@ -69,7 +70,7 @@ class StringIterator { // Returns the rune at the cursor position. // Precondition: |more()|. peek(): number { - return this.str.codePointAt(this.position)!; + return codePointAtOrThrow(this.str, this.position); } // Advances the cursor by |n| positions, which must be ASCII runes. @@ -89,7 +90,7 @@ class StringIterator { // Returns the rune at the cursor position, and advances the cursor // past it. Precondition: |more()|. pop(): number { - const r = this.str.codePointAt(this.position)!; + const r = codePointAtOrThrow(this.str, this.position); this.position += charCount(r); return r; } @@ -203,9 +204,11 @@ class Parser { // unicodeTable() returns the Unicode RangeTable identified by name // and the table of additional fold-equivalent code points. // Returns null if |name| does not identify a Unicode character range. - static unicodeTable( - name: string, - ): { tab: any; fold: any; sign: number } | null { + static unicodeTable(name: string): { + tab: UnicodeRangeTable | null; + fold: UnicodeRangeTable | null; + sign: number; + } | null { if (name === "Any") { return { tab: Parser.ANY_TABLE, fold: Parser.ANY_TABLE, sign: +1 }; } @@ -305,7 +308,7 @@ class Parser { return -1; } - let max; + let max: number; if (!t.lookingAt(",")) { max = min; } else { @@ -315,8 +318,11 @@ class Parser { } if (t.lookingAt("}")) { max = -1; - } else if ((max = Parser.parseInt(t)) === -1) { - return -1; + } else { + max = Parser.parseInt(t); + if (max === -1) { + return -1; + } } } @@ -351,7 +357,7 @@ class Parser { } for (let i = 0; i < name.length; i++) { - const c = name.codePointAt(i)!; + const c = codePointAtOrThrow(name, i); if (c !== 0x5f && !isalnum(c)) { return false; } @@ -364,7 +370,7 @@ class Parser { // -1 => bad format. -2 => format ok, but integer overflow. static parseInt(t: StringIterator): number { const start = t.pos(); - while (t.more() && t.peek()! >= 0x30 && t.peek()! <= 0x39) { + while (t.more() && t.peek() >= 0x30 && t.peek() <= 0x39) { t.skip(1); } @@ -453,7 +459,7 @@ class Parser { throw new RE2JSSyntaxException(Parser.ERR_TRAILING_BACKSLASH); } let c = t.pop(); - bigswitch: switch (c) { + switch (c) { case 0x31: case 0x32: case 0x33: @@ -462,15 +468,15 @@ class Parser { case 0x36: case 0x30: case 0x37: { - if (c !== 0x30 && (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37)) { + if (c !== 0x30 && (!t.more() || t.peek() < 0x30 || t.peek() > 0x37)) { break; } let r = c - 0x30; for (let i = 1; i < 3; i++) { - if (!t.more() || t.peek()! < 0x30 || t.peek()! > 0x37) { + if (!t.more() || t.peek() < 0x30 || t.peek() > 0x37) { break; } - r = r * 8 + t.peek()! - 0x30; + r = r * 8 + t.peek() - 0x30; t.skip(1); } return r; @@ -486,7 +492,10 @@ class Parser { while (true) { if (!t.more()) { - break bigswitch; + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_ESCAPE, + t.from(startPos), + ); } c = t.pop(); if (c === 0x7d) { @@ -494,16 +503,22 @@ class Parser { } const v = unhex(c); if (v < 0) { - break bigswitch; + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_ESCAPE, + t.from(startPos), + ); } r = r * 16 + v; if (r > MAX_RUNE) { - break bigswitch; + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_ESCAPE, + t.from(startPos), + ); } nhex++; } if (nhex === 0) { - break bigswitch; + break; } return r; } @@ -567,7 +582,7 @@ class Parser { numCap: number; namedGroups: Map; stack: Regexp[]; - free: any; + free: Regexp | null; numRegexp: number; numRunes: number; repeats: number; @@ -612,7 +627,8 @@ class Parser { this.height.delete(re); } if (re.subs !== null && re.subs.length > 0) { - re.subs[0] = this.free; + // subs[0] doubles as the free-list next pointer while re is on the list. + re.subs[0] = this.free as Regexp; } this.free = re; } @@ -668,8 +684,11 @@ class Parser { } calcSize(re: Regexp, force = false): number { - if (!force && this.size!.has(re)) { - return this.size!.get(re)!; + if (!force && this.size !== null) { + const cached = this.size.get(re); + if (cached !== undefined) { + return cached; + } } let size = 0; @@ -721,7 +740,7 @@ class Parser { } size = Math.max(1, size); - this.size!.set(re, size); + this.size?.set(re, size); return size; } @@ -741,8 +760,11 @@ class Parser { } calcHeight(re: Regexp, force = false): number { - if (!force && this.height!.has(re)) { - return this.height!.get(re)!; + if (!force && this.height !== null) { + const cached = this.height.get(re); + if (cached !== undefined) { + return cached; + } } let h = 1; for (let sub of re.subs) { @@ -751,7 +773,7 @@ class Parser { h = 1 + hsub; } } - this.height!.set(re, h); + this.height?.set(re, h); return h; } @@ -1082,14 +1104,18 @@ class Parser { while (t.more()) { { let repeatPos = -1; - bigswitch: switch (t.peek()) { + switch (t.peek()) { case 0x28: if (t.lookingAt("(?")) { // Flag changes and non-capturing groups. this.parsePerlFlags(t); break; } - this.op(Regexp.Op.LEFT_PAREN)!.cap = ++this.numCap; + const lparen = this.op(Regexp.Op.LEFT_PAREN); + if (lparen === null) { + throw new Error("op(LEFT_PAREN) unexpectedly returned null"); + } + lparen.cap = ++this.numCap; t.skip(1); // '(' break; case 0x7c: @@ -1110,7 +1136,11 @@ class Parser { break; case 0x24: if ((this.flags & ONE_LINE) !== 0) { - this.op(Regexp.Op.END_TEXT)!.flags |= WAS_DOLLAR; + const endText = this.op(Regexp.Op.END_TEXT); + if (endText === null) { + throw new Error("op(END_TEXT) unexpectedly returned null"); + } + endText.flags |= WAS_DOLLAR; } else { this.op(Regexp.Op.END_LINE); } @@ -1143,7 +1173,10 @@ class Parser { op = Regexp.Op.QUEST; break; } - this.repeat(op!, min, max, repeatPos, t, lastRepeatPos); + if (op === null) { + throw new Error("repeat op unexpectedly null"); + } + this.repeat(op, min, max, repeatPos, t, lastRepeatPos); // (min and max are now dead.) break; } @@ -1173,18 +1206,22 @@ class Parser { case 0x5c: { const savedPos = t.pos(); t.skip(1); // '\\' + let handled = false; if (t.more()) { const c = t.pop(); switch (c) { case 0x41: this.op(Regexp.Op.BEGIN_TEXT); - break bigswitch; + handled = true; + break; case 0x62: this.op(Regexp.Op.WORD_BOUNDARY); - break bigswitch; + handled = true; + break; case 0x42: this.op(Regexp.Op.NO_WORD_BOUNDARY); - break bigswitch; + handled = true; + break; case 0x43: // any byte; not supported throw new RE2JSSyntaxException( @@ -1205,16 +1242,18 @@ class Parser { let j = 0; while (j < lit.length) { - const codepoint = lit.codePointAt(j)!; + const codepoint = codePointAtOrThrow(lit, j); this.literal(codepoint); j += charCount(codepoint); } - break bigswitch; + handled = true; + break; } case 0x7a: this.op(Regexp.Op.END_TEXT); - break bigswitch; + handled = true; + break; default: t.rewindTo(savedPos); break; @@ -1222,6 +1261,7 @@ class Parser { } else { t.rewindTo(savedPos); } + if (handled) break; const re = this.newRegexp(Regexp.Op.CHAR_CLASS); re.flags = this.flags; @@ -1231,7 +1271,7 @@ class Parser { if (this.parseUnicodeClass(t, cc)) { re.runes = cc.toArray(); this.push(re); - break bigswitch; + break; } } // Perl character class escape. @@ -1239,7 +1279,7 @@ class Parser { if (this.parsePerlClassEscape(t, cc)) { re.runes = cc.toArray(); this.push(re); - break bigswitch; + break; } t.rewindTo(savedPos); this.reuse(re); @@ -1311,7 +1351,10 @@ class Parser { ); // "(?P" or "(?" } // Like ordinary capture, but named. - const re = this.op(Regexp.Op.LEFT_PAREN)!; + const re = this.op(Regexp.Op.LEFT_PAREN); + if (re === null) { + throw new Error("op(LEFT_PAREN) unexpectedly returned null"); + } re.cap = ++this.numCap; if (this.namedGroups.get(name)) { throw new RE2JSSyntaxException( @@ -1496,9 +1539,8 @@ class Parser { } t.pop(); // e.g. advance past 'd' in "\\d" const p = t.from(beforePos); - const perlGroups = getPerlGroups(); - const g = perlGroups.has(p) ? perlGroups.get(p) : null; - if (g === null) { + const g = getPerlGroups().get(p); + if (g === undefined) { return false; } cc.appendGroup(g, (this.flags & FOLD_CASE) !== 0); @@ -1521,9 +1563,8 @@ class Parser { const name = cls.substring(0, i + 2); // "[:alnum:]" t.skipString(name); - const posixGroups = getPosixGroups(); - const g = posixGroups.has(name) ? posixGroups.get(name) : null; - if (g === null) { + const g = getPosixGroups().get(name); + if (g === undefined) { throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, name); } cc.appendGroup(g, (this.flags & FOLD_CASE) !== 0); @@ -1559,7 +1600,7 @@ class Parser { } c = t.pop(); - let name; + let name: string; if (c !== 0x7b) { // Single-letter name. @@ -1598,6 +1639,12 @@ class Parser { const tab = pair.tab; const fold = pair.fold; // fold-equivalent table + if (tab === null) { + throw new RE2JSSyntaxException( + Parser.ERR_INVALID_CHAR_RANGE, + t.from(startPos), + ); + } // Variation of CharClass.appendGroup() for tables. if ((this.flags & FOLD_CASE) === 0 || fold === null) { cc.appendTableWithSign(tab, sign); diff --git a/packages/re2/src/Prefilter.ts b/packages/re2/src/Prefilter.ts index a476010..54e04be 100644 --- a/packages/re2/src/Prefilter.ts +++ b/packages/re2/src/Prefilter.ts @@ -5,7 +5,7 @@ import type { MachineUTF16Input } from "./MachineInput.js"; class Prefilter { type: number; - subs: any[]; + subs: Prefilter[]; str: string; static Type = { NONE: 0, EXACT: 1, AND: 2, OR: 3 }; @@ -38,137 +38,134 @@ class Prefilter { } } -class PrefilterTree { - static build(re: Regexp): Prefilter { - const pf = PrefilterTree.fromRegexp(re); - return PrefilterTree.simplify(pf); - } +const fromRegexp = (re: Regexp): Prefilter => { + if (!re) return new Prefilter(Prefilter.Type.NONE); + + switch (re.op) { + case Regexp.Op.NO_MATCH: + case Regexp.Op.EMPTY_MATCH: + case Regexp.Op.BEGIN_LINE: + case Regexp.Op.END_LINE: + case Regexp.Op.BEGIN_TEXT: + case Regexp.Op.END_TEXT: + case Regexp.Op.WORD_BOUNDARY: + case Regexp.Op.NO_WORD_BOUNDARY: + case Regexp.Op.CHAR_CLASS: + case Regexp.Op.ANY_CHAR_NOT_NL: + case Regexp.Op.ANY_CHAR: { + return new Prefilter(Prefilter.Type.NONE); + } - static fromRegexp(re: Regexp): Prefilter { - if (!re) return new Prefilter(Prefilter.Type.NONE); - - switch (re.op) { - case Regexp.Op.NO_MATCH: - case Regexp.Op.EMPTY_MATCH: - case Regexp.Op.BEGIN_LINE: - case Regexp.Op.END_LINE: - case Regexp.Op.BEGIN_TEXT: - case Regexp.Op.END_TEXT: - case Regexp.Op.WORD_BOUNDARY: - case Regexp.Op.NO_WORD_BOUNDARY: - case Regexp.Op.CHAR_CLASS: - case Regexp.Op.ANY_CHAR_NOT_NL: - case Regexp.Op.ANY_CHAR: { + case Regexp.Op.LITERAL: { + if (re.runes.length === 0 || (re.flags & FOLD_CASE) !== 0) { + // Skip case-folded literals for simplicity return new Prefilter(Prefilter.Type.NONE); } - - case Regexp.Op.LITERAL: { - if (re.runes.length === 0 || (re.flags & FOLD_CASE) !== 0) { - // Skip case-folded literals for simplicity - return new Prefilter(Prefilter.Type.NONE); - } - const pf = new Prefilter(Prefilter.Type.EXACT); - let str = ""; - for (let i = 0; i < re.runes.length; i++) { - str += String.fromCodePoint(re.runes[i]); - } - pf.str = str; - return pf; - } - - case Regexp.Op.CAPTURE: - case Regexp.Op.PLUS: { - return PrefilterTree.fromRegexp(re.subs[0]); - } - - case Regexp.Op.REPEAT: { - if (re.min >= 1) { - return PrefilterTree.fromRegexp(re.subs[0]); - } - return new Prefilter(Prefilter.Type.NONE); + const pf = new Prefilter(Prefilter.Type.EXACT); + let str = ""; + for (let i = 0; i < re.runes.length; i++) { + str += String.fromCodePoint(re.runes[i]); } + pf.str = str; + return pf; + } - case Regexp.Op.CONCAT: { - const pf = new Prefilter(Prefilter.Type.AND); - for (const sub of re.subs) { - pf.subs.push(PrefilterTree.fromRegexp(sub)); - } - return pf; - } + case Regexp.Op.CAPTURE: + case Regexp.Op.PLUS: { + return fromRegexp(re.subs[0]); + } - case Regexp.Op.ALTERNATE: { - const pf = new Prefilter(Prefilter.Type.OR); - for (const sub of re.subs) { - pf.subs.push(PrefilterTree.fromRegexp(sub)); - } - return pf; + case Regexp.Op.REPEAT: { + if (re.min >= 1) { + return fromRegexp(re.subs[0]); } - - default: - return new Prefilter(Prefilter.Type.NONE); + return new Prefilter(Prefilter.Type.NONE); } - } - static simplify(pf: Prefilter): Prefilter { - if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) { + case Regexp.Op.CONCAT: { + const pf = new Prefilter(Prefilter.Type.AND); + for (const sub of re.subs) { + pf.subs.push(fromRegexp(sub)); + } return pf; } - if (pf.type === Prefilter.Type.AND) { - const newSubs = []; - for (const sub of pf.subs) { - const s = PrefilterTree.simplify(sub); - if (s.type !== Prefilter.Type.NONE) { - if (s.type === Prefilter.Type.AND) { - newSubs.push(...s.subs); - } else { - newSubs.push(s); - } - } + case Regexp.Op.ALTERNATE: { + const pf = new Prefilter(Prefilter.Type.OR); + for (const sub of re.subs) { + pf.subs.push(fromRegexp(sub)); } - - if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE); - if (newSubs.length === 1) return newSubs[0]; - pf.subs = newSubs; return pf; } - if (pf.type === Prefilter.Type.OR) { - const newSubs = []; - for (const sub of pf.subs) { - const s = PrefilterTree.simplify(sub); - if (s.type === Prefilter.Type.NONE) { - // If any branch of an OR has no requirements, the whole OR has no requirements - return new Prefilter(Prefilter.Type.NONE); - } - if (s.type === Prefilter.Type.OR) { + default: + return new Prefilter(Prefilter.Type.NONE); + } +}; + +const simplify = (pf: Prefilter): Prefilter => { + if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) { + return pf; + } + + if (pf.type === Prefilter.Type.AND) { + const newSubs: Prefilter[] = []; + for (const sub of pf.subs) { + const s = simplify(sub); + if (s.type !== Prefilter.Type.NONE) { + if (s.type === Prefilter.Type.AND) { newSubs.push(...s.subs); } else { newSubs.push(s); } } - if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE); - if (newSubs.length === 1) return newSubs[0]; - - // De-duplicate EXACT branches - const seen = new Set(); - const uniqueSubs = []; - for (const sub of newSubs) { - if (sub.type === Prefilter.Type.EXACT) { - if (!seen.has(sub.str)) { - seen.add(sub.str); - uniqueSubs.push(sub); - } - } else { + } + + if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE); + if (newSubs.length === 1) return newSubs[0]; + pf.subs = newSubs; + return pf; + } + + if (pf.type === Prefilter.Type.OR) { + const newSubs: Prefilter[] = []; + for (const sub of pf.subs) { + const s = simplify(sub); + if (s.type === Prefilter.Type.NONE) { + // If any branch of an OR has no requirements, the whole OR has no requirements + return new Prefilter(Prefilter.Type.NONE); + } + if (s.type === Prefilter.Type.OR) { + newSubs.push(...s.subs); + } else { + newSubs.push(s); + } + } + if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE); + if (newSubs.length === 1) return newSubs[0]; + + // De-duplicate EXACT branches + const seen = new Set(); + const uniqueSubs: Prefilter[] = []; + for (const sub of newSubs) { + if (sub.type === Prefilter.Type.EXACT) { + if (!seen.has(sub.str)) { + seen.add(sub.str); uniqueSubs.push(sub); } + } else { + uniqueSubs.push(sub); } - pf.subs = uniqueSubs; - return pf; } - + pf.subs = uniqueSubs; return pf; } -} + + return pf; +}; + +const PrefilterTree = { + build: (re: Regexp): Prefilter => simplify(fromRegexp(re)), +}; export { Prefilter, PrefilterTree }; diff --git a/packages/re2/src/RE2.ts b/packages/re2/src/RE2.ts index 130a8ca..a3f8d4d 100644 --- a/packages/re2/src/RE2.ts +++ b/packages/re2/src/RE2.ts @@ -45,7 +45,11 @@ class RE2 { this.prefixRune = 0; if (this.prefix.length > 0) { - this.prefixRune = this.prefix.codePointAt(0)!; + const cp = this.prefix.codePointAt(0); + if (cp === undefined) { + throw new Error("RE2: prefix has no code point"); + } + this.prefixRune = cp; } this.namedGroups = re.namedGroups; @@ -57,7 +61,7 @@ class RE2 { } matchPrefixComplete( - input: any, + input: MachineUTF16Input, pos: number, anchor: number, ncap: number, @@ -98,7 +102,7 @@ class RE2 { } executeEngine( - input: any, + input: MachineUTF16Input, pos: number, anchor: number, ncap: number, diff --git a/packages/re2/src/Unicode.ts b/packages/re2/src/Unicode.ts index 7a4edc5..90555b6 100644 --- a/packages/re2/src/Unicode.ts +++ b/packages/re2/src/Unicode.ts @@ -1,4 +1,4 @@ -import { UnicodeRangeTable } from "./UnicodeRangeTable.js"; +import type { UnicodeRangeTable } from "./UnicodeRangeTable.js"; import { UnicodeTables } from "./UnicodeTables.js"; /** @@ -101,8 +101,10 @@ function isUpper(r: number): boolean { function simpleFold(r: number): number { // Consult caseOrbit table for special cases (3+ element cycles, lossy // mappings like ſ→S, and Turkic-specific self-loops). - if (UnicodeTables.CASE_ORBIT!.has(r)) { - return UnicodeTables.CASE_ORBIT!.get(r)!; + const caseOrbit = UnicodeTables.CASE_ORBIT; + const folded = caseOrbit.get(r); + if (folded !== undefined) { + return folded; } // Fallback for 2-element orbits: use raw native case conversion. @@ -111,13 +113,13 @@ function simpleFold(r: number): number { const s = String.fromCodePoint(r); const lower = s.toLowerCase(); if (lower.length === s.length) { - const lowerCp = lower.codePointAt(0)!; - if (lowerCp !== r) return lowerCp; + const lowerCp = lower.codePointAt(0); + if (lowerCp !== undefined && lowerCp !== r) return lowerCp; } const upper = s.toUpperCase(); if (upper.length === s.length) { - const upperCp = upper.codePointAt(0)!; - if (upperCp !== r) return upperCp; + const upperCp = upper.codePointAt(0); + if (upperCp !== undefined && upperCp !== r) return upperCp; } return r; } diff --git a/packages/re2/src/UnicodeTables.ts b/packages/re2/src/UnicodeTables.ts index 6fa9f02..0753935 100644 --- a/packages/re2/src/UnicodeTables.ts +++ b/packages/re2/src/UnicodeTables.ts @@ -132,7 +132,10 @@ class LazyDecoder { return key in this.initializer; } get(key: string): V | null { - if (this.cache.has(key)) return this.cache.get(key)!; + const cached = this.cache.get(key); + if (cached !== undefined || this.cache.has(key)) { + return cached ?? null; + } const fn = this.initializer[key]; const val = fn ? fn() : null; this.cache.set(key, val); @@ -140,461 +143,828 @@ class LazyDecoder { } } -class UnicodeTables { - private static _CASE_ORBIT: Map | null = null; - static get CASE_ORBIT(): Map { - if (!this._CASE_ORBIT) { - this._CASE_ORBIT = decodeOrbit( - "rDqpII-LsD+0HGrpIsCxJzElODoODrOnByP-Mz+HTieNj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeE1eDmpII0fjB4c+BgkHChkHKikHDjkHBkkHImkHZnkHhhGlkH9O70H-Io8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HJ48HB58HB68HB78HB88HB98HB+8HB-8HJo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HM89HLlaFs+HQwcQwdQ8-HzJpdErCBlGgphBokHjMu+pBBv+pBDy+pBBz+pBB0+pBB1+pBw5Um4+BBl4+B68cg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417CD717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27C", - ); - } - return this._CASE_ORBIT; +let _CASE_ORBIT: Map | null = null; +const getCASE_ORBIT = (): Map => { + if (!_CASE_ORBIT) { + _CASE_ORBIT = decodeOrbit( + "rDqpII-LsD+0HGrpIsCxJzElODoODrOnByP-Mz+HTieNj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeE1eDmpII0fjB4c+BgkHChkHKikHDjkHBkkHImkHZnkHhhGlkH9O70H-Io8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HJ48HB58HB68HB78HB88HB98HB+8HB-8HJo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HM89HLlaFs+HQwcQwdQ8-HzJpdErCBlGgphBokHjMu+pBBv+pBDy+pBBz+pBB0+pBB1+pBw5Um4+BBl4+B68cg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417CD717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27C", + ); } + return _CASE_ORBIT; +}; - // Additions from Unicode 15.0 → 16.0 per stable general-category name. - // Merged unconditionally with platform sweep output; no-op on 16.0+ engines. - private static _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder( - { - L: () => - decodeRanges( - "pkHBBh6iBCBNCBkvXzBB36BbBKWB9JCB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBjhDsBBz8HxmWxmWBcBDgwhCgwhCBsTB", - false, - ), - LC: () => decodeRanges("pkHBh6iBCNC0rZVLV", true), - Ll: () => decodeRanges("qkHj6iBj6iBO1sZ1sZBUB", false), - Lm: () => decodeRanges("uqjChBhBx+XCBpBBB", false), - Lo: () => - decodeRanges( - "guhCzBB36BDBCzLzLBBB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBmhDnBB18HxmWxmWBcBDgwhCgwhCBsTB", - false, - ), - Lu: () => decodeRanges("pkHi6iBi6iBBOOC0rZ0rZBUB", false), - M: () => - decodeRanges( - "3kCymhCymhCBDBvM8lB8lBBHBCDDCDBCEBCPPB47C47CkuQRB-lhBBB", - false, - ), - Mc: () => decodeRanges("49kCCBIDDCDBCBBCvavaswSCB", false), - Mn: () => - decodeRanges( - "3kCymhCymhCBDBvM-lB-lBBEBOECPBB47CkuQkuQBKBECB-lhBBB", - false, - ), - N: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true), - Nd: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true), - P: () => decodeRanges("u6GBBwBvv8Bvv8BmzBBBCBBpgCssUssUBBBwkeAB", false), - Pd: () => decodeRanges("urjCA", true), - Po: () => decodeRanges("u6GBBwB1i+B1i+BBCCBpgCpgCssUCBwkeAB", false), - S: () => - decodeRanges( - "nhJCBz+CDBlPBBK-82B-82BBxzvBxzvBBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", - false, - ), - Sm: () => decodeRanges("usjCB", true), - So: () => - decodeRanges( - "nhJCBz+CDBlPBBKxwmDxwmDBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", - false, - ), - }, - ); +// Additions from Unicode 15.0 → 16.0 per stable general-category name. +// Merged unconditionally with platform sweep output; no-op on 16.0+ engines. +const _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({ + C: () => + decodeRanges( + "AfBgDgBBOrWrWBHHBCBICCVuMuMnBBBzBBBE4B4BBGBcDBHQBXhGhGxBBB8BBBmDNB8BBByBBBQddBCCMEBgBHBsCiFiFJBBDBBXIICCBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBPMMBEB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKMMBDBbEByBPBDBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBjoIBvLBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCB-FCBHBBHBBHBBECBIIIBLBDBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIB-BGGBLBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMBxhBPBXJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBF-6DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBrCHBxDUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEvq3VBxHvw-FB", + false, + ), + Cc: () => decodeRanges("AfgDgB", true), + Cf: () => + decodeRanges( + "tFzqBzqBBEBXhGhGyBhMhMBxCxCs5D9-B9-BBDBbEByBEBCJBw03B6H6HBBBimEQQj7IPBhjiBDBwmFHBn0rYffB+CB", + false, + ), + Cn: () => + decodeRanges( + "4bBBHDBICCVuMuMnBBBzBBBE4B4BBGBcDBHKBvI9B9BBmDmDBMB8BBByBBBQddBCCMEBgBDDBDBuHJJBDDBXXICCBBBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBbFB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKmDmDNBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBDBvzIBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCC-FCBHBBHBBHBBECBIIIBIBGBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIBlCJBCBBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMB3iBJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBJ76DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBjGUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEwi3VBCdBhD-DBxHvw-BB---BBB---BBB", + false, + ), + Co: () => decodeRanges("gg4B-nGh4hc9--BD9--B", true), + Cs: () => decodeRanges("gg2B--B", true), + L: () => + decodeRanges( + "hCZBHZBwBLLFGGBVBCeBCpOBFLBPEBICCiEEBCBBDDBCHHCCBCCCBSBCyCBCqEBJlFBClBBDHHBnBBoCaBFDBuBqBBkBBBCiDBCQQBIIBLLBBBDRRCdBe4CBMZZBfBKBBFGGBUBFKKEYYBXBIKBGXBCFBSpBB7B1BBETTIJBQPBFHBDBBDVBCGBCEEBCBERROBBCCBPBBLJJBEBFBBDVBCGBCBBCBBCBBgBDBCUUBBBRIBCCBCVBCGBCBBCEBETTQBBYMMBGBDBBDVBCGBCBBCEBEffBCCBBBQSSCFBECBCDBEBBCCCBEEBEEBBBELBX1B1BBGBCCBCWBCPBEbbBBBDDDBffFHBCCBCWBCJBCEBEgBgBBCCBQQBSSBHBCCBCoBBDRRGCBJCBZFBGRBEXBCIBCDDBFB7BvBBCBBNGB7BBBCCCBDBCXBCCCBIBCBBKDDBDBCWWBCBhBgCgCBGBCjBBcEB0DqBBVRRBEBFDBEEEBIIBBBFMBNSSBkBBCGGDqBBCsKBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBmBPBR1CBDFBErTBDQBCZBGqCBHHBIRBOSBPRBPMBCCBQzBBkBFFkC4CBIEBDhBBCGGBkCBLeByBdBDEBMrBBFZB3BWBK0BBzC+C+CBtBBSHB3BdBOBBLrBBbjBBqBCBLjBBDKBGqBBDCBqBDBCFBCBBEGGB+FBhC1IBDFBDlBBDFBDHBCGCBdBD0BBCGBCEEBBBCGBEDBDFBFMBGCBCGB1DOORMBmDFFDJBCEEBDBHGCBCBCKBDDBGEBF1B1BB8zC8zCBjHBHDBEBBNlBBCGGD3BBIRRBVBKGBCGBCGBCGBCGBCGBCGBCGBxC2O2OBrBrBBDBGBBF1CBHCBC5CBCDBGqBBC9CBSfBxBPBhQ-tGBhCs0VBkCtBBDsIBEPBLBBVuBBReBDlCByBIBDmDBDiCBDBBCCCBGBWPBCCBCDBCWBezBBPxBB-BFBECCBMMBaBLWBacBIuBBdRRBDBCJBLEBCoBBYCBCHBVWBEEEBwBBCEEBDDBDBDCCZCBDKBICBNFBDFBDFBKGBCGBCqBBCNBHyDBej9KBNWBFwBBloItLBDpDBnBGBNEBGCCBIBCMBCEBCCCBCCBCCBqDBiBqLBT-BBD1BBpBLB1DEBCmEBlBZBHZBM4CBEFBDFBDFBDCBkBLBCZBCSBCBBCOBDNBjB6DBmMcBEwBBwBfBOTBCHBHlBBLdBDjBBFHBxB9EBTjBBFjBBFnBBJzBBNKBCOBCGBCBBCKBCOBCGBCBBEzBBN2JBKVBLHBZFBCpBBCIBmCFBDCCBqBBCBBEDDBVBLWBKeBiCSBCBBLVBLZBnC3BBHBBhCQQBCBCCBCcBrBcBEcBkBHBCbBc1BBLVBLSBORBvDoCB4ByBBOyBBOjBBnBbBKWB7HpBBHBBRCB8BcBLJJBUBrBRBvBUBcWBN0BB6BBBDOOBrBBhBYBbjBBeDDJiBBENNBuBBPDBWCCkBRBCYBUBBgCGBCCCBCBCOBCJBIuBBnBHBDBBDVBCGBCBBCEBETTNEBfJBCDDClBBCaaCtBtBBzBBTDBVCBfvBBVBBC5F5FBtBBqBDBlBvBBV8B8BBpBBOoCoCBZBmBGB6FrBB1D-BBgBHBDDDBGBCBBCXBQCC-CHBDmBBRCCdLLBmBBIWWMtBBUTTBnCBoGgBBgBIBCkBBSyByBBcBxDGBCBBClBBWaaBEBCBBCfBPoKoKBRBQCCBLBChBB9DwCwCB4cBnHjGBtyCgDBQvhBBSFBa68DBGmSB61GdBj3B4RBIeBSuCBSdBTvBBRDBgBUBGSBxNsBB0G-BBhEqCBGjCjCBLBhCBBCddB2-FBJ1mBBqBJBo3IDBCGBCBBCiJBQeeBBBDPPBCBJrMBloCqDBGMBEIBIJBn7F0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDYBCYBCeBCYBCeBCYBCeBCYBCeBCYBCHB15BeBHFBmI9BBzEsBBLGBRiKiKBcBTrBBlPbBlHdBDwPwPBFBCDBCBBCOBCkGB8BjCBI1lB1lBBCBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQBlqE-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB", + false, + ), + LC: () => + decodeRanges( + "hCZBHZB7BLLBVBCeBCiGBCDBFvGBCaBhGDBDBBECBCHHCCBCCCBSBCyCBCqEBJlFBClBBKoBB44ClBBCGGDqBBDCBhV1CBDFBjkCKBGqBBDCBhCrBBgCMBChBBmD1IBDFBDlBBDFBDHBCGCBdBD0BBCGBCEEBBBCGBEDBDFBFMBGCBCGBmIFFDJBCEEBDBHGCBCBCFBFDDBCBGEBF1B1BB8zC8zCB6DBDmDBHDBEBBNlBBCGGzoetBBTbBnEtCBCWBEDBC9BBDBBCCCBGBZBBE2Z2ZBpBBGIBIvCBh6TGBNEBqgBZBHZBmlBvCBhDjBBFjBB1DKBCOBCGBCBBCKBCOBCGBCBBk2ByBBOyBB+CVBLVB74C-BBhrV-BBhsZ0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDYBCYBCeBCYBCeBCYBCeBCYBCeBCYBCHB15BJBCTBHFB2uCjCB", + false, + ), + Ll: () => + decodeRanges( + "hDZB7BqBqBBWBCHBC2BCBQCBuBCDECBBBDCCDEEBFFDEEBBBDDDCCCDCCBCCDEECDDBDDBBBHGDCOCBSCBDDCEEC4BCBFBDDDBCCFICBjCBCaBiGCCEEEBBBTccBhBBCBBECBCWCBDBCGDB0B0BBuBBCgBCK0BCDMCBgDCxBoBBo6CqBBDCB5XFBjkCIBC2D2DBqBBgCMBChBBnD0ECBHBCgDCBHBJFBLHBJHBJFBLHBJHBJNBDHBJHBJHBJEBCBBHEEBBBCBBJDBDBBJHBLCBCBBzIEEBEEcKFDBBJDBF2B2Bs1CvBBCEEBGCFCCBCCBEBGiDCBIICFFNlBBCGG0oesBCUaCoEMCBBBC+BCBGBCCCDICFCCDCCBBBCSCGGGCMCFCCDEECICbEE2ZqBBGIBIvCBh6TGBNEBqhBZBumBnBBpEjBB8EKBCOBCGBCBBk4ByBB+DVB75CfBhsVfB7sZZBbGBCRBbZBbDBCCCBFBCKBbZBbZBbZBbZBbZBbZBbZBbZBbbBdYBCFBbYBCFBbYBCFBbYBCFBbYBCFBC15B15BBIBCTBHFB4vChBB", + false, + ), + Lm: () => + decodeRanges( + "wVRBFLBPEBICCmEGG-OnHnHlFBBuIBBFgBgBKEEhFoFoF1mBgEgE2R72B72BsDkTkTxOFBvF+BBOjBjBBjBByVOORMBg-CBByHgGgG2OsBsBBDBGiDiDB+C+CBBB34bjnBjnBBEBvIzDzDdBB6DIBxCYYqDCBEBB2OXXqEtDtDWBBoDDBKngVngVuBBBh-BFBCpBBCIB0sBhBhBxuXDB9PCBpBBBnRMBhCBBCtgQtgQBCBCGBCBByhM9BBqGGBudgjBgjB", + false, + ), + Lo: () => + decodeRanges( + "qFQQhIFFBCBxG8Z8ZBZBFDBuBfBCJBkBBBCiDBCZZBLLBBBDRRCdBe4CBMZZBfBWVBrBYBIKBGXBCFBSoBB8B1BBETTIJBROBFHBDBBDVBCGBCEEBCBERROBBCCBPBBLJJBEBFBBDVBCGBCBBCBBCBBgBDBCUUBBBRIBCCBCVBCGBCBBCEBETTQBBYMMBGBDBBDVBCGBCBBCEBEffBCCBBBQSSCFBECBCDBEBBCCCBEEBEEBBBELBX1B1BBGBCCBCWBCPBEbbBBBDDDBffFHBCCBCWBCJBCEBEgBgBBCCBQQBSSBHBCCBCoBBDRRGCBJCBZFBGRBEXBCIBCDDBFB7BvBBCBBNFB8BBBCCCBDBCXBCCCBIBCBBKDDBDBYDBhBgCgCBGBCjBBcEB0DqBBVRRBEBFDBEEEBIIBBBFMBNyDyDBnKBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBmBPByDrTBDQBCZBGqCBHHBIRBOSBPRBPMBCCBQzBBpBkCkCBhBBC0BBIEBDhBBCGGBkCBLeByBdBDEBMrBBFZB3BWBK0BBxFuBBSHB3BdBOBBLrBBbjBBqBCBLdByDDBCFBCBBE7hB7hBBCB4-C3BBZWBKGBCGBCGBCGBCGBCGBCGBCGBoR2B2BF1CBJCCB4CBFGGBpBBC9CBSfBxBPBhQ-tGBhC0wUBC2jBBkCnBBJrIBFPBLBBjCyByBBkCBqFoDoDEGBCCBCDBCWBezBBPxBB-BFBECCBMMBaBLWBacBIuBBuBEBDIBLEBCoBBYCBCHBVPBCFBEEEBwBBCEEBDDBDBDCCZBBEKBIPPBEBDFBDFBKGBCGByEiBBej9KBNWBFwBBloItLBDpDBkCCCBIBCMBCEBCCCBCCBCCBqDBiBqLBT-BBD1BBpBLB1DEBCmEBqDJBCsBBDeBEFBDFBDFBDCBkBLBCZBCSBCBBCOBDNBjB6DBmMcBEwBBwBfBOTBCHBHlBBLdBDjBBFHBhEtCBjDnBBJzBB9CzBBN2JBKVBLHB5EFBDCCBqBBCBBEDDBVBLWBKeBiCSBCBBLVBLZBnC3BBHBBhCQQBCBCCBCcBrBcBEcBkBHBCbBc1BBLVBLSBORBvDoCB4FjBBnBDBCxJxJBoBBHBBRCB8BcBLJJBUBrBRBvBUBcWBN0BB6BBBDOOBrBBhBYBbjBBeDDJiBBENNBuBBPDBWCCkBRBCYBUBBgCGBCCCBCBCOBCJBIuBBnBHBDBBDVBCGBCBBCEBETTNEBfJBCDDClBBCaaCtBtBBzBBTDBVCBfvBBVBBC5F5FBtBBqBDBlBvBBV8B8BBpBBOoCoCBZBmBGB6FrBB0GHBDDDBGBCBBCXBQCC-CHBDmBBRCCdLLBmBBIWWMtBBUTTBnCBoGgBBgBIBCkBBSyByBBcBxDGBCBBClBBWaaBEBCBBCfBPoKoKBRBQCCBLBChBB9DwCwCB4cBnHjGBtyCgDBQvhBBSFBa68DBGmSB61GdBj3B4RBIeBSuCBSdBTvBB0BUBGSB0NnBB2MqCBGwFwFB2-FBJ1mBBqBJB43IiJBQeeBBBDPPBCBJrMBloCqDBGMBEIBIJBxzI2P2PBrBBiBiKiKBcBTrBBlPaBmHdBDwPwPBFBCDBCBBCOBCkGB8pBDBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQBlqE-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB", + false, + ), + Lt: () => decodeRanges("lOGDnB2sH2sHBGBJHBJHBNQQwBAB", false), + Lu: () => + decodeRanges( + "hCZBmDWBCGBiB2BCDOCDuBCBECEBBCCCBCCBBBDDBCBBCCBEBBCBBCECBCCDCCBCCBBBCCCBEEIJDCMCDQCDDDCCBC4BCIBBCBBDCCBCBCGCiJCCEJJHCCBBBCCCBCCBPBCIBkBDDBBBEWCGDDCBBDyBBxBgBCK2BCBMCD+CCDlBBq6ClBBCGGzW1CB0kCHHBpBBDCBhK0ECKgDCKHBJFBLHBJHBJFBMGCJHBpCDBNDBNDBNEBMDBnIFFECBDCBDEEBDBHGCBCBDDBLBBG+B+B9zCvBBxBCCBBBDGCBCBCDDJCBCgDCJCCFuqeuqeCqBCUaCoEMCE8BCLECBICFCCDCCEUCBDBCEBCOCBCBCCCBEEGGCZs5Vs5VBYBmmBnBBpEjBB9EKBCOBCGBCBBr3ByBB+EVB75CfBhsVfBhtZZBbZBbZBbCCBGDBDDBCBCHBbZBbBBCDBDHBCGBcBBCDBCEBCEEBFBcZBbZBbZBbZBbZBbZBfYBiBYBiBYBiBYBiBYBiB2pE2pEBgBB", + false, + ), + M: () => + decodeRanges( + "gYvDB0IGBoIsBBCCCBCCBCCpCKBxBUBRmDmDBFBDFBDBBCDBkBffBZB8CKB7BIBKZZBCBCIBCCBCEBsBCB8BIBrBXBCgBB3BCBCRBCGBLBBeCB5BCCBFBDBBDCBKLLBbbDCB5BCCBDBFBBDCBEffBEEMCB5BCCBGBCCBCCBVBBXFBCCB5BCCBFBDBBDCBICBLBBf8B8BBDBECBCDBKpBpBBDB4BCCBFBCCBCDBIBBMBBeCB5BCCBFBCCBCDBIBBMBBQNNBCB4BBBCGBCCBCDBKLLBeeBBBnCFFBEBCCCBGBTBB+BDDBFBNHBjDDDBHBMGBqCBBcECFBByBTBCBBGKBCjBBKlDlDBSBYDBFCBCCBDGBEDBOLBCLLBCBgWCBzdDBdCBeBBfBBhCfBKuBuBBBBC2D2DBjBjB3DLBFLB8GEB6BJBCcBDxBxBBdByBEBwBQBnBIBNCBfMB5BNBxBTB5ECBCUBFHHDCBnG-BBxWgBB--CCBuEhDhDBeBrRFBqDBB1udDBCJBhBBBxCBBxIEEFYYBDBF0C0CBzBzBBQBbRBOnBnBBGBaMBtBDBwBNBlBkCkCBMBNJJBuBuBBBBzBCCBBBDBBGBBCqBqBBDBGBBtHHBCBBx5TiXiXBOBRPBuejHjH2EEBn0BCBCBBGDBpBCBFmFmFB+R+RBCBiCEB+JBBwCDBnCKByBDB7DCB2BOBqBDDBLLBCBuBKBI+B+BBBBlBNBRBBtBNNBBBxBNBJDBCBB9CLBHDD+ELBWDB4BBBCGBDBBDCBKLLBDDBFBEEBkCIBCDDCDBCEBCPPBzCzCBQBYyCyCBSBsHGBDIBcBBzCQBrDMBmDOBhIOB2HFBCBBDDBCCCBuEuEBFBDGBEddBIBpBGBCDBJKKBJBvBPB2MHBCHBzCVBCNB7DFBECCBCCBFBCjCjCBDBCBBCEB8KDBKBBCxBxBBFBEEBYmnFmnFHOBpmLRBhuCEB8BGB5gBCCB1BBIDByCMMBslTslTBizEizEBsBBDWB-QEBEFBJHBDGBfDB1ECB89B2BBFxBBJPPXEBCOBxqBGBCQBDGBCBBCEBlDhFhFBFB4L+B+BBCB9PDB-HBBhXGBuDGB29lYvHB", + false, + ), + Mc: () => + decodeRanges( + "joC4B4BDCBJDBCBBzBBB7BCBHBBDBBLsBsB7BCBjC7B7BBBBJCCB2B2BB7B7BCHHBDDBLLnDBBCBBECBCCBLqBqBBBB+BDB+BBB7BCCBDBDBBCBBKBBdPPB7B7BBBBGCBCCBLrBrBBsCsCBBBHHBTBBrKBBgCsFsFBFFHDDBaaBLLBBBDGBWBBDFBDLLBBB5zBffiEIIBGBCBB7KDBDCBFBBCFBhHBB7BCCKCCBJJBEByExBxBGCCBDBCBB+BffFBBD9B9BDCBCEEBxBxBBGBJBBsFWW35EBB0-dBBD5C5CBzBzBBOBvEBBwBxBxBBFFBDDBBBvDBBDBBZuBuBCuDuDDBBGuHuHBCCBCCBCC0gZCCgEuBuBBBBFBB0DZZB8B8BxBCBKBBO+C+CBBBEBBCrFrFBBBgBBB7BBBCDBDBBDCBKLLB1C1CBBBIDDCDBCBBCmDmDBBBJBBErDrDBBBHCCBCBDuHuHBBBHDBDyDyDBBBJBBCuDuDCBBHoDoDCBBFmImIBBBK4H4HBEBCBBFDDCvEvEBBBJDBF1C1CeBB-B4M4MPrDrDIDD2GEBFBBC-K-KBNNxBBBJBBCpvQpvQBBBlxD2BBpDBB0rYBBHFB", + false, + ), + Me: () => decodeRanges("okBBB1xF-wB-wBBCBCCBsshBCB", false), + Mn: () => + decodeRanges( + "gYvDB0IEBqIsBBCCCBCCBCCpCKBxBUBRmDmDBFBDFBDBBCDBkBffBZB8CKB7BIBKZZBCBCIBCCBCEBsBCB8BIBrBXBCfB4BCCFHBFEEBFBLBBe7B7BFDBJVVBbbDBB6BFFBFFBDDBBBEffBEEMBB6BFFBDBCBBFVVBXXBEBC7B7BDCCBCBJIIBMMBff+BNNzBEE4BCCBBBGCBCDBIBBMBBe7B7BDHHGBBVBBdBB6BBBFDBJVVBeepCIIBBBC7C7CDGBNHBjDDDBHBMGBqCBBcEC4BNBCEBCBBGKBCjBBKnDnDBCBCFBCBBDBBaBBFCBRDBODDBHHQgWgWBBBzdCBeBBfBBfBBhCBBCGBJDDBJBKuBuBBBBC2D2DBjBjB3DCBFBBKHHBBB8GBBD7B7BCGBCCCDHBHJBDxBxBBMBCPByBDBxBCCBDBCGGpBIBNBBhBDBDBBCCB5BCCBEECCB7BHBDBB5ECBCMBCGBFHHEBBnG-BBxWMBFEEBKB--CCBuEhDhDBeBrRDBsDBB1udFFBIBhBBBxCBBxIEEFaaBGG4EBBbRBOnBnBBGBaKBvBCBxBDDBCBDBBoBkCkCBEBDBBDBBNJJwB0B0BCCBDBBGBBCrBrBBJJvHDDFx5Tx5TiXPBRPBuejHjH2EEBn0BCBCBBGDBpBCBFmFmFB+R+RBCBiCEB+JBBwCDBnCKByBDB8D3B3BBNBqBDDBLLBBByBDBDBBI+B+BBBBlBEBCHB-BNNB1B1BBHBLDBDgDgDBBBDCCBHHD+E+EEHBWBB6BBBEmBmBBFBEEBnCFBOECPBB2CHBDCBCYY1CFBCFFBCCBvHvHBCBHBBCBBcBB2CHBDCCBrDrDCDDBEBCmDmDCDDBCBCEBkIIBCBBhIBBCFFxEDBDBBFhBhBBIBpBFBDDBJKKBEBDCBvBMBCBB3MGBCFBCzCzCBUBDGBCBBCBB7DFBECCBCCBFBCpCpCBEEC8K8KBMMB1B1BBDBGCCYmnFmnFHOBpmLLBECBhuCEB8BGB5gBgCgCBCByC5lT5lTBizEizEBsBBDWBhRCBSHBDGBfDB1ECB89B2BBFxBBJPPXEBCOBxqBGBCQBDGBCBBCEBlDhFhFBFB4L+B+BBCB9PDB-HBBhXGBuDGB29lYvHB", + false, + ), + N: () => + decodeRanges( + "wBJB5DBBGDDBBBitBJBnEJBnGJB9MJB3DJBFFBtDJB3DJB3DJBDFBvDMB0DJBJGBoDJBpDGBISBuDJBhDJB3DJBnCTBtIJBnCJBwWTBybCBwHJBHJBXJBtJJBhEKBmFJBHJB3FJB3CJBnEJBHJB3gBEEBEBHJBnGyBBDEB3W7BBvCVB3TdBqrBqYqYaIBPCB4KDBrEJBfHBCOBhBJBoBOBh7cJB9FJBhKFB7EJBnBJBnGJBXJB3CJB3MJB34UJBuPsBBN4BBSBB2KaBlBDBeJJnEEBrGJBvdHBaGBoBIBsCEBXFBhFBBDPBDtBBhCIB1BBBfCBsCEBpDHBZHBqBGBrKFBxBJBHJB3IeB-EJBrBDBxDGBnEdBhEJB9BJBxEJBITB8HJB3KJB3DJB3LJBnDJBHTBtCLBlNSB+CJB3UJB3CcBkHJBnCJBnNJBnDUBshBuDBimPJBnpCJB3CJBnEJBCGBvQJBnIWB6yXJBnuBTBNTBtDYB2iBxBBhqCJBnNJB3PJB4HJBtWIBhEJB4Y6BBCCBCDBtCsBBCOBjeMBk3CJB", + false, + ), + Nd: () => + decodeRanges( + "wBJnxBJnEJnGJ9MJ3DJ3DJ3DJ3DJ3DJ3DJ3DJ3DJ3DJhDJ3DJnCJ3IJnCJn6BJnBJtJJhEJnFJHJ3FJ3CJnEJHJnuiBJnVJnBJnGJXJ3CJ3MJ34UJnsBJnkCJHJ9YJhEJ9BJxEJ3IJ3KJ3DJ3LJnDJHTtCJnNJnDJ3UJ3CJ3HJnCJnNJ3uQJnpCJ3CJnEJ3QJ37XJ12CxBhqCJnNJ3PJ4HJ2aJ30EJ", + true, + ), + Nl: () => + decodeRanges("u3FCBwzCiBBDDB-zDaaBHBPCBs1dJBxyW0BBtOJJnEEBrhIuDB", false), + No: () => + decodeRanges( + "yFBBGDDBBB2pCFB5LFB5DCBmEGB6GGBSIByNJB2hBTB0jBJBhP20B20BEFBHJBnGPBqB3W3WB6BBvCVB3TdBqrB1kB1kBBCBrEJBfHBCOBhBJBoBOBxrdFBymWsBBiCDBSBB2KaBlBDB1pBHBaGBoBIBsCEBXFBhFBBDPBDtBBhCIB1BBBfCBsCEBpDHBZHBqBGBrKFBhLeB-EJBrBDBxDGBnETB8LTBmqBBBvNIBobSB0aUBn8SGB-YWBqhZTBNTBtDYBvqFIBid6BBCCBCDBtCsBBCOBjeMB", + false, + ), + P: () => + decodeRanges( + "hBCBCFBCDBLBBEBBbCBCccCkBkBGEELBBEEE-VJJzOFBqBBB0BCCDDDtBBBVBBCBBOCCBBBrCDBnDsBsBBMBqHCB3BOBgBmImIBLLtE5D5D6DnMnMNwLwL7CLLBpFpFBNBCmBmBBCBoCrCrCBDBFBBwDFBsFlTlTBHB4EuTuTtBBBvCCBoCBB+ECBCCBmBKB6JBB5GBBhEGBCFBhFBBLGBdCB9DDB8BEB-BBBhCHBM9Z9ZBWBJTBCMBCLBfBBPBB6TDBeBB+hBNBwCBBgBJB0MVBgCDBhBBB8XDBCBBxDwEwEBtBBCfBDLBkNCBFJBDLBRNNjD7C7CjgdBBuICBkDLL0DFB9LDB3CBBpBCBCyByBBwBwBiDMBRBB9DDB-DBBRBB6HzqUzqUBxGxGBIBXiBBCNBCFFCBB2ECBCFBCDBLBBEBBbCBCccCCCBFB7MCB9UxBxB-MoXoXoGgBgBxIIBnBxDxDBFBjCGB6CDByO-J-JoFEBtBDB+FGBuDBBCDB-DDBxBBBwCDBFOOCCB5CFBsDrJrJBCCBzDzDBDBLBBCpDpD7HWBqDCBdMBtCjEjEBBB9HpIpIBBB8E9C9CBGB0CCBCEB+CJB4GgDgDBDBrBBBmUBBrCMBwFxjBxjBBDB97CBB8zOBBmEiCiCBDBJpRpRBBBoJDBoK9lT9lTovHEB07C-a-aBAB", + false, + ), + Pc: () => decodeRanges("-Cg-Hg-HBUU-u3BBBZCBwHAB", false), + Pd: () => + decodeRanges( + "tB9qB9qB0BiyDiyDmgBqgCqgCBEBiwDDDgBBBFdd-NUUwDxszBxszBBmBmBLqFqFhzD-J-J", + false, + ), + Pe: () => + decodeRanges( + "pB0B0BgB+1D+1DC-6B-6BqtC4B4BQ7T7TCff-hBMCxChBhBCGC1MUChCCCiBmhBmhBCECtBGCtNICEGCDBB-ozB6G6GeOCESSCCCrF0B0BgBGD", + false, + ), + Pf: () => decodeRanges("7F+6H+6HEddpuDCCFDDQEE", false), + Pi: () => decodeRanges("rFt7Ht7HDBBDaapuDCCFDDQEE", false), + Po: () => + decodeRanges( + "hBCBCCBDECBLLBEEBcclCGGPBBI-V-VJzOzOBEBqB3B3BDDDtBBBVBBCBBOCCBBBrCDBnDsBsBBMBqHCB3BOBgBmImIBLLtE5D5D6DnMnMNwLwL7CLLBpFpFBNBCxDxDrCEBFBBwDFBsFlTlTBHBmY9D9DBBBoCBB+ECBCCBmBFBCDB6JBB5GBBhEGBCFBhFBBLGBdCB9DDB8BEB-BBBhCHBMjajaBJJBGBJIBDDBDCBEKBCCCBIB7kDDBCBBxDwEwEBFFBBBDDDBHBCBBCDDBLLBDBCJBDDBCCCBLBDCBtNCB6B+F+FjgdBBuICBkDLL0DFB9LDB3CBBpBCBCyByBBwBwBiDMBRBB9DDB-DBBRBB6HlxUlxUBFBDXXVBBDDBECBCDBICBHCCB2E2EBBBCCBDECBLLBEEBcclBDDB7M7MBBB9UxBxB-MoXoXoGgBgBxIIBnBxDxDBFBjCGB6CDB5dEBtBDB+FGBuDBBCDB-DDBxBBBwCDBFOOCCB5CFBsDrJrJBCCBzDzDBDBLBBCpDpD7HWBqDCBdMBtCjEjEBBB9HpIpIBBB8E9C9CBGB0CCBCEB+CJB4GgDgDBDBrBBBmUBBrCMBwFxjBxjBBDB97CBB8zOBBmEiCiCBDBJpRpRBBBoJDBoK9lT9lTovHEB07C-a-aBAB", + false, + ), + Ps: () => + decodeRanges( + "oBzBzBgB-1D-1DC-6B-6B-rCEEnB4B4BQ7T7TCff-hBMCxChBhBCGC1MUChCCCiBmhBmhBCECaTTCECtNICEGCDipzBipzB4GeeCMCESSCCCrFzBzBgBEEDAB", + false, + ), + S: () => + decodeRanges( + "kBHHRCBgBCCcCCkBEBCBBDCCBCBDEEfgBgBrODBNNBGGBCCCBPB2DPPBxDxDsErIrIBBB3DCBDDDBvGvGLUUB4H4HIBBpEqLqLBHHB2H2H-DjEjEBGBlEwGwGqBmGmGiGCBQCCBBBDFBVECmEHBCFBCBBGDBmGBBxXJB0WuLuLlL+E+EBgBBiLJBKIBhiBCCBBBMCBOCBOCBOBBmCOOoBCBOCBUgBBgCBBCDBCBBLCCBBBGFBCECFMMBFFBDBGDBC7B7BBFFB2LBFcBD+HBXKByCtCBXnTBtBwBBDeBLyMBX+BBFfBD1LBDfBCoDBmHFBmLBBvBZBC4CBN1GBbPBFOOBNNWBBHBB8CBB0HBBFJBhBlBBKRRBdBMdBJQQBeBLmBBQ-JBhuG-BBx0V2BB6RWBKBBoDBB+EDBLDB+RCBiHPPB+9T+9TpEQB+LPBgEtBtBBCBjDCCBBBD7E7EHRRBBBgBCCcCCiEGBCGBOBB6JIB6BQBDCBCMBEwBwBBrBB7zBBBwSmWmWBwtCwtC2kCcBr6SDBG3qU3qUk7DvHBRzNB9EzDB9B1HBLmBBD7BBGCBXBBIdBF8BBWhCBE7F7FB1CBrbaagBaagBaagBaagBaa9B-PB4BDBzBHBCNBCBBp2BwNwNttCEE+DiOiOBvIvIBqBBFjDBNOBDOBCOBCkBBYgFB5BcBOrBBFIBIBBPFB7E3eBFQBEMBE2DBF+CBHLBFQQBKBF3BBJJBHnBBJdBDLBFBB-BzKBNNBDMBEJBG3BBIOBDKBHIBIyEBC7CB", + false, + ), + Sc: () => + decodeRanges( + "kB+D+DBCBqnB8D8DzPBBzPBBI2H2HoImSmS8sClmClmCBfB47hBkuVkuVtD7E7E8GBBEBB3-HDB-4wBxtCxtC", + false, + ), + Sk: () => + decodeRanges( + "+CCCoCHHFEEqQDBNNBGGBCCCBPB2DPPBjoBjoB15FCCBBBMCBOCBOCBOBB9kEBBkzdWBKBBoDBBxePPBniUniUBPB8bCCjF4g9B4g9BBDB", + false, + ), + Sm: () => + decodeRanges( + "rBRRBBB+BCCuBFFmBgBgB-XwQwQBBB8xGOOoBCBOCBsEoBoBBDBHlClCBDBGBBFGDIgBgBBDDCgBgBBqIBhBBB7CffBXBpBFB2OKK3BHBwDxKxKBDBDeBLPBhIiEBX+BBFfBDhIBxBUBDFB9+zB5Z5ZCCBlFRRBBB+BCCkEHHBCBitDBBypyBaagBaagBaagBaagBaat5FBB", + false, + ), + So: () => + decodeRanges( + "mFDDFCCyerIrIBgEgEBvGvGLUUB4H4HkQ2L2LjEFBClElEwGqBqBoMCBQCCBBBDFBVECmEHBCFBCBBGDBmGBBxXJB0WzWzW+EhBBiLJBKIBksBBBCDBCBBLCCBHHBEBCECFMMBPPCBBC7B7BBKKBDBDDBCBBCBBCGBCeBDBBCCCBdBtIHBFTBDGBDwCBCdBanBBHnCBXKByCtCBX2FBCIBC1BBJuDBC3HBtBrBBhC-HBhQvBBWBBHmBBDfBCoDBmHFBmLBBvBZBC4CBN1GBbPBFOOBNNWBBHBBxKBBFJBhBlBBKRRBdBMdBJQQBeBLmBBQ-JBhuG-BBx0V2BBibDBLBBC+R+RBBBn2UPBgEuBuBBBBlPEEFBBOBB6JIB6BQBDCBCMBEwBwBBrBB7zBBBwS3jD3jD2kCHBFQBr6SDBG3qU3qUk7DvHBRzNB9EzDB9B1HBLmBBD7BBGCBXBBIdBF8BBWhCBE7F7FB1CBqlB-PB4BDBzBHBCNBCBBp2B96C96CiEyWyWBqBBFjDBNOBDOBCOBCkBBYgFB5BcBOrBBFIBIBBPFB7E6HBG3WBFQBEMBE2DBF+CBHLBFQQBKBF3BBJJBHnBBJdBDLBFBB-BzKBNNBDMBEJBG3BBIOBDKBHIBIyEBC7CB", + false, + ), + Z: () => decodeRanges("gBgEgEgvFgsCgsCBJBeBBGwBwBh9DAB", false), + Zl: () => decodeRanges("ohIA", true), + Zp: () => decodeRanges("phIA", true), + Zs: () => decodeRanges("gBgEgEgvFgsCgsCBJBlBwBwBh9DAB", false), +}); - // Additions from Unicode 15.0 → 16.0 per stable script name. - private static _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ - Arabic: () => decodeRanges("3kCrxhCrxhCBBB4BAB", false), - Balinese: () => decodeRanges("u6GBwBA", true), - Common: () => +// Additions from Unicode 15.0 → 16.0 per stable script name. +const _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({}); + +// Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw +// SyntaxError on these names, so platform sweep is impossible. +const _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ + Adlam: () => new UnicodeRangeTable(decodeRanges("go6DrCFJFB", true)), + Ahom: () => new UnicodeRangeTable(decodeRanges("g4lCaDOFW", true)), + Anatolian_Hieroglyphs: () => + new UnicodeRangeTable(decodeRanges("ggxCmS", true)), + Arabic: () => + new UnicodeRangeTable( + decodeRanges( + "gwBEBCFBCNBCCBCfBCJBMZBCrDBChBBxCvBBxHeBCBBGqCBCcBxy8ByDBRqLBDvCBD1BBIhBhBBOBxDEBCmEBk7DeBkCCB4BDBh43BDBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQB1BBB", + false, + ), + ), + Armenian: () => new UnicodeRangeTable(decodeRanges("xpBlBDxBDCks9BE", true)), + Avestan: () => new UnicodeRangeTable(decodeRanges("g4iC1BEG", true)), + Balinese: () => new UnicodeRangeTable(decodeRanges("g4GsCCxB", true)), + Bamum: () => new UnicodeRangeTable(decodeRanges("g1pB3CpowB4R", true)), + Bassa_Vah: () => new UnicodeRangeTable(decodeRanges("w26CdDF", true)), + Batak: () => new UnicodeRangeTable(decodeRanges("g+GzBJD", true)), + Bengali: () => + new UnicodeRangeTable( + decodeRanges("gsCDBCHBDBBDVBCGBCEEBCBDIBDBBDDBJFFBCCBDBDYB", false), + ), + Bhaiksuki: () => new UnicodeRangeTable(decodeRanges("ggnCICsBCNLc", true)), + Bopomofo: () => new UnicodeRangeTable(decodeRanges("qXB6wLqBxDf", true)), + Brahmi: () => new UnicodeRangeTable(decodeRanges("ggkCtCFjBKA", true)), + Braille: () => new UnicodeRangeTable(decodeRanges("ggK-H", true)), + Buginese: () => new UnicodeRangeTable(decodeRanges("gwGbDB", true)), + Buhid: () => new UnicodeRangeTable(decodeRanges("g6FT", true)), + Canadian_Aboriginal: () => + new UnicodeRangeTable(decodeRanges("ggF-TxRlC7tgCP", true)), + Carian: () => new UnicodeRangeTable(decodeRanges("g1gCwB", true)), + Caucasian_Albanian: () => + new UnicodeRangeTable(decodeRanges("wphCzBMA", true)), + Chakma: () => new UnicodeRangeTable(decodeRanges("gokC0BCR", true)), + Cham: () => new UnicodeRangeTable(decodeRanges("gwqB2BKNDJDD", true)), + Cherokee: () => new UnicodeRangeTable(decodeRanges("g9E1CDFz7lBvC", true)), + Chorasmian: () => new UnicodeRangeTable(decodeRanges("w9jCb", true)), + Common: () => + new UnicodeRangeTable( + decodeRanges( + "AgCBbFBbuBBCOBCEBYgBgBiOmBBGEBDTB1DKKHCC+THHPEEhB9E9ElQiEiEB6mB6mB2MDBjJwvBwvBBBBoCBBsGBBCumBumBOIIBCBCFBCCBDmYmYBKBD2CBCKBEKBCOBSgBBgClBBCCBDFBCaBCQBqBCBF5UBXKBW-cBhIzTBDfBCoDBhQ9CBzMUBCCCBXBQHBFDB8CBBE7C7CB0E0EBOBhBlBBKxBxBB+BBgBwCBwB5C5CBmFBhuG-BBhoWhBBnDCBmFJB1HhFhFsMPPBzuUzuUBxGxGBIBXiBBCSBCDB0ECCBeBbFBbKBLuBuBBhChCBFBCGBLEBjICBFsBBEIBxCMB0BsBBlHaBltuBDB96D5HBHzNB9EzDB9B1HBLmBBD9BBEQBJBBIdBF8BB2GTBNTBN2CBKYBoE0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDjJBDxBByjFjCBtC8BBjWrBBFjDBNOBDOBCOBCkBBLtFB5BZBCBBOrBBFIBIBBPFB7E3eBFQBEMBE2DBF+CBHLBFQQBKBF3BBJJBHnBBJdBDLBFBB-BzKBNNBDMBEJBG3BBIOBDKBHIBIyEBClDBoghYffB+CB", + false, + ), + ), + Coptic: () => new UnicodeRangeTable(decodeRanges("ifNxkKzDGG", true)), + Cuneiform: () => new UnicodeRangeTable(decodeRanges("ggoC5cnDuDCEMjG", true)), + Cypriot: () => + new UnicodeRangeTable(decodeRanges("ggiCFBDCCBqBBCBBEDD", false)), + Cypro_Minoan: () => new UnicodeRangeTable(decodeRanges("w8rCiD", true)), + Cyrillic: () => + new UnicodeRangeTable( + decodeRanges("ggBkEBDoFBx6FKBhFtCtCojEfBhie-CBv8VBBhw4B9BBiBAB", false), + ), + Deseret: () => new UnicodeRangeTable(decodeRanges("gghCvC", true)), + Devanagari: () => + new UnicodeRangeTable(decodeRanges("goCwCFODZh7nBfhwcJ", true)), + Dives_Akuru: () => + new UnicodeRangeTable(decodeRanges("gomCGBDDDBGBCBBCdBCBBDLBKJB", false)), + Dogra: () => new UnicodeRangeTable(decodeRanges("ggmC7B", true)), + Duployan: () => new UnicodeRangeTable(decodeRanges("ggvDqDGMEIIJDD", true)), + Egyptian_Hieroglyphs: () => + new UnicodeRangeTable(decodeRanges("ggsC1iBL68D", true)), + Elbasan: () => new UnicodeRangeTable(decodeRanges("gohCnB", true)), + Elymaic: () => new UnicodeRangeTable(decodeRanges("g-jCW", true)), + Ethiopic: () => + new UnicodeRangeTable( decodeRanges( - "nhJCBz+CDBlPBBKxwmDxwmDB4HBHzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", + "gwEoCBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBDfBEZBnvGWBKGBCGBCGBCGBCGBCGBCGBCGBjpfFBDFBDFBKGBCGBylvCGBCDBCBBCOB", false, ), - Cyrillic: () => decodeRanges("pkHB", true), - Egyptian_Hieroglyphs: () => decodeRanges("gjtC68D", true), - Han: () => decodeRanges("w-6FtT", true), - Kawi: () => decodeRanges("66nCA", true), - Khitan_Small_Script: () => decodeRanges("-njDA", true), - Latin: () => decodeRanges("r+pBCNC", true), - Myanmar: () => decodeRanges("w2lCT", true), - }); + ), + Garay: () => new UnicodeRangeTable(decodeRanges("gqjClBEcJB", true)), + Georgian: () => + new UnicodeRangeTable( + decodeRanges("glElBBCGGDqBBCDBx8CqBBDCBhiElBBCGG", false), + ), + Glagolitic: () => + new UnicodeRangeTable(decodeRanges("ggL-Ch9sDGCQDGCBCE", true)), + Gothic: () => new UnicodeRangeTable(decodeRanges("w5gCa", true)), + Grantha: () => + new UnicodeRangeTable( + decodeRanges("g4kCDBCHBDBBDVBCGBCBBCEBDIBDBBDCBDHHGGBDGBEEB", false), + ), + Greek: () => + new UnicodeRangeTable( + decodeRanges( + "wbDBCCBDDBCFFCCCBBBCCCBSBC+BBPPBnpGEBzBEBFEB1ChKhKBUBDFBDlBBDFBDHBCGCBdBD0BBCOBCNBDFBCSBDCBCIBoJ-xiB-xiB7uVuCBSgj0Bgj0BBkCB", + false, + ), + ), + Gujarati: () => + new UnicodeRangeTable( + decodeRanges("h0CCBCIBCCBCVBCGBCBBCEBDJBCCBCCBDQQBCBDLBIGB", false), + ), + Gunjala_Gondi: () => + new UnicodeRangeTable(decodeRanges("grnCFCBCkBCBCFIJ", true)), + Gurmukhi: () => + new UnicodeRangeTable( + decodeRanges("hwCCBCFBFBBDVBCGBCBBCBBCBBDCCBDBFBBDCBEIIBCBCIIBPB", false), + ), + Gurung_Khema: () => new UnicodeRangeTable(decodeRanges("go4C5B", true)), + Han: () => + new UnicodeRangeTable( + decodeRanges( + "g0LZBC4CBN1GBwBCCaIBPDBle-tGBhC-vUBhoWtLBDpDBpodBBNBBvgkB-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB", + false, + ), + ), + Hangul: () => + new UnicodeRangeTable( + decodeRanges("goE-HvxHBiI9CyDeiCei3dckUj9KNWFwBl9JeEFDFDFDC", true), + ), + Hanifi_Rohingya: () => new UnicodeRangeTable(decodeRanges("gojCnBJJ", true)), + Hanunoo: () => new UnicodeRangeTable(decodeRanges("g5FU", true)), + Hatran: () => new UnicodeRangeTable(decodeRanges("gniCSCBGE", true)), + Hebrew: () => + new UnicodeRangeTable( + decodeRanges("xsB2BBJaBFFBpp9BZBCEBCCCBCCBCCBIB", false), + ), + Hiragana: () => + new UnicodeRangeTable(decodeRanges("hiM1CBHCBi7-C+IBTeeBBBulQAB", false)), + Imperial_Aramaic: () => new UnicodeRangeTable(decodeRanges("giiCVCI", true)), + Inherited: () => + new UnicodeRangeTable( + decodeRanges( + "gYvDB2IBBlOKBbhXhXBCB8qEeBiQCBCMBCGBFHHEBBnG-BBtQBBjGgBB65DDBsDBBmrzBPBRNBwejHjH7iEl+uBl+uBBsBBDWBhRCBSHBDGBfDBz6rYvHB", + false, + ), + ), + Inscriptional_Pahlavi: () => + new UnicodeRangeTable(decodeRanges("g7iCSGH", true)), + Inscriptional_Parthian: () => + new UnicodeRangeTable(decodeRanges("g6iCVDH", true)), + Javanese: () => new UnicodeRangeTable(decodeRanges("gsqBtCDJFB", true)), + Kaithi: () => new UnicodeRangeTable(decodeRanges("gkkCiCLA", true)), + Kannada: () => + new UnicodeRangeTable(decodeRanges("gkDMCCCWCJCEDICCCDIBHBCDDJCC", true)), + Katakana: () => + new UnicodeRangeTable( + decodeRanges( + "hlM5CBDCBxHPBxGuBBC3CBvgzBJBCsBBzisBDBCGBCBBCgJgJBBBzBPPBCB", + false, + ), + ), + Kawi: () => new UnicodeRangeTable(decodeRanges("g4nCQCoBEc", true)), + Kayah_Li: () => new UnicodeRangeTable(decodeRanges("goqBtBCA", true)), + Kharoshthi: () => + new UnicodeRangeTable(decodeRanges("gwiCDCBGHCCCcDCFJII", true)), + Khitan_Small_Script: () => + new UnicodeRangeTable(decodeRanges("k-7C84G84GB0OBqBAB", false)), + Khmer: () => new UnicodeRangeTable(decodeRanges("g8F9CDJHJnPf", true)), + Khojki: () => new UnicodeRangeTable(decodeRanges("gwkCRCuB", true)), + Khudawadi: () => new UnicodeRangeTable(decodeRanges("w1kC6BGJ", true)), + Kirat_Rai: () => new UnicodeRangeTable(decodeRanges("gq7C5B", true)), + Lao: () => + new UnicodeRangeTable( + decodeRanges("h0DBBCCCBDBCXBCCCBVBDEBCCCBFBCJBDDB", false), + ), + Latin: () => + new UnicodeRangeTable( + decodeRanges( + "hCZBHZBwBQQGWBCeBCgOBoBEB8wGlBBHwBBGDBGMBClCBiC-HByLOORMBuEBBHccSoBB42CfBj1elDBEiCBDBBCCCBGBWNBxZqBBCIBCDB38TGB7gBZBHZBmhCFBCpBBCIBm61BeBHFB", + false, + ), + ), + Lepcha: () => new UnicodeRangeTable(decodeRanges("ggH3BEOEC", true)), + Limbu: () => new UnicodeRangeTable(decodeRanges("goGeBCLBFLBFEEBKB", false)), + Linear_A: () => new UnicodeRangeTable(decodeRanges("gwhC2JKVLH", true)), + Linear_B: () => + new UnicodeRangeTable(decodeRanges("gggCLCZCSCBCODNjB6D", true)), + Lisu: () => new UnicodeRangeTable(decodeRanges("wmpBvBx1eA", true)), + Lycian: () => new UnicodeRangeTable(decodeRanges("g0gCc", true)), + Lydian: () => new UnicodeRangeTable(decodeRanges("gpiCZGA", true)), + Mahajani: () => new UnicodeRangeTable(decodeRanges("wqkCmB", true)), + Makasar: () => new UnicodeRangeTable(decodeRanges("g3nCY", true)), + Malayalam: () => + new UnicodeRangeTable(decodeRanges("goDMCCCyBCCCFFPDZ", true)), + Mandaic: () => new UnicodeRangeTable(decodeRanges("giCbDA", true)), + Manichaean: () => new UnicodeRangeTable(decodeRanges("g2iCmBFL", true)), + Marchen: () => new UnicodeRangeTable(decodeRanges("wjnCfDVCN", true)), + Masaram_Gondi: () => + new UnicodeRangeTable(decodeRanges("gonCGBCBBCrBBECCBCCBHBJJB", false)), + Medefaidrin: () => new UnicodeRangeTable(decodeRanges("gy7C6C", true)), + Meetei_Mayek: () => new UnicodeRangeTable(decodeRanges("g3qBWqGtBDJ", true)), + Mende_Kikakui: () => new UnicodeRangeTable(decodeRanges("gg6DkGDP", true)), + Meroitic_Cursive: () => + new UnicodeRangeTable(decodeRanges("gtiCXFTDtB", true)), + Meroitic_Hieroglyphs: () => + new UnicodeRangeTable(decodeRanges("gsiCf", true)), + Miao: () => new UnicodeRangeTable(decodeRanges("g47CqCF4BIQ", true)), + Modi: () => new UnicodeRangeTable(decodeRanges("gwlCkCMJ", true)), + Mongolian: () => + new UnicodeRangeTable(decodeRanges("ggGBBDCCBSBH4CBIqBB2t-BMB", false)), + Mro: () => new UnicodeRangeTable(decodeRanges("gy6CeCJFB", true)), + Multani: () => + new UnicodeRangeTable(decodeRanges("g0kCGBCCCBCBCOBCKB", false)), + Myanmar: () => new UnicodeRangeTable(decodeRanges("ggE-EhqmBeiDfxibT", true)), + Nabataean: () => new UnicodeRangeTable(decodeRanges("gkiCeJI", true)), + Nag_Mundari: () => new UnicodeRangeTable(decodeRanges("wm5DpB", true)), + Nandinagari: () => new UnicodeRangeTable(decodeRanges("gtmCHDtBDK", true)), + New_Tai_Lue: () => new UnicodeRangeTable(decodeRanges("gsGrBFZHKEB", true)), + Newa: () => new UnicodeRangeTable(decodeRanges("gglC7CCE", true)), + Nko: () => new UnicodeRangeTable(decodeRanges("g+B6BDC", true)), + Nushu: () => new UnicodeRangeTable(decodeRanges("h-7CvsQvsQBqMB", false)), + Nyiakeng_Puachue_Hmong: () => + new UnicodeRangeTable(decodeRanges("go4DsBENDJFB", true)), + Ogham: () => new UnicodeRangeTable(decodeRanges("g0Fc", true)), + Ol_Chiki: () => new UnicodeRangeTable(decodeRanges("wiHvB", true)), + Ol_Onal: () => new UnicodeRangeTable(decodeRanges("wu5DqBFA", true)), + Old_Hungarian: () => new UnicodeRangeTable(decodeRanges("gkjCyBOyBIF", true)), + Old_Italic: () => new UnicodeRangeTable(decodeRanges("g4gCjBKC", true)), + Old_North_Arabian: () => new UnicodeRangeTable(decodeRanges("g0iCf", true)), + Old_Permic: () => new UnicodeRangeTable(decodeRanges("w6gCqB", true)), + Old_Persian: () => new UnicodeRangeTable(decodeRanges("g9gCjBFN", true)), + Old_Sogdian: () => new UnicodeRangeTable(decodeRanges("g4jCnB", true)), + Old_South_Arabian: () => new UnicodeRangeTable(decodeRanges("gziCf", true)), + Old_Turkic: () => new UnicodeRangeTable(decodeRanges("ggjCoC", true)), + Old_Uyghur: () => new UnicodeRangeTable(decodeRanges("w7jCZ", true)), + Oriya: () => + new UnicodeRangeTable(decodeRanges("h4CCCHDBDVCGCBCEDIDBDCICFBCEDR", true)), + Osage: () => new UnicodeRangeTable(decodeRanges("wlhCjBFjB", true)), + Osmanya: () => new UnicodeRangeTable(decodeRanges("gkhCdDJ", true)), + Pahawh_Hmong: () => + new UnicodeRangeTable(decodeRanges("g46ClCLJCGCUGS", true)), + Palmyrene: () => new UnicodeRangeTable(decodeRanges("gjiCf", true)), + Pau_Cin_Hau: () => new UnicodeRangeTable(decodeRanges("g2mC4B", true)), + Phags_Pa: () => new UnicodeRangeTable(decodeRanges("giqB3B", true)), + Phoenician: () => new UnicodeRangeTable(decodeRanges("goiCbEA", true)), + Psalter_Pahlavi: () => new UnicodeRangeTable(decodeRanges("g8iCRIDNG", true)), + Rejang: () => new UnicodeRangeTable(decodeRanges("wpqBjBMA", true)), + Runic: () => new UnicodeRangeTable(decodeRanges("g1FqCEK", true)), + Samaritan: () => new UnicodeRangeTable(decodeRanges("ggCtBDO", true)), + Saurashtra: () => new UnicodeRangeTable(decodeRanges("gkqBlCJL", true)), + Sharada: () => new UnicodeRangeTable(decodeRanges("gskC-C", true)), + Shavian: () => new UnicodeRangeTable(decodeRanges("wihCvB", true)), + Siddham: () => new UnicodeRangeTable(decodeRanges("gslC1BDlB", true)), + SignWriting: () => new UnicodeRangeTable(decodeRanges("gg2DrUQECO", true)), + Sinhala: () => + new UnicodeRangeTable( + decodeRanges("hsDCBCRBEXBCIBCDDBFBEFFBEBCCCBGBHJBDCBt-gCTB", false), + ), + Sogdian: () => new UnicodeRangeTable(decodeRanges("w5jCpB", true)), + Sora_Sompeng: () => new UnicodeRangeTable(decodeRanges("wmkCYIJ", true)), + Soyombo: () => new UnicodeRangeTable(decodeRanges("wymCyC", true)), + Sundanese: () => new UnicodeRangeTable(decodeRanges("g8G-BhIH", true)), + Sunuwar: () => new UnicodeRangeTable(decodeRanges("g+mChBPJ", true)), + Syloti_Nagri: () => new UnicodeRangeTable(decodeRanges("ggqBsB", true)), + Syriac: () => new UnicodeRangeTable(decodeRanges("g4BNC7BDCxIK", true)), + Tagalog: () => new UnicodeRangeTable(decodeRanges("g4FVKA", true)), + Tagbanwa: () => new UnicodeRangeTable(decodeRanges("g7FMCCCB", true)), + Tai_Le: () => new UnicodeRangeTable(decodeRanges("wqGdDE", true)), + Tai_Tham: () => new UnicodeRangeTable(decodeRanges("gxG+BCcDKHJHN", true)), + Tai_Viet: () => new UnicodeRangeTable(decodeRanges("g0qBiCZE", true)), + Takri: () => new UnicodeRangeTable(decodeRanges("g0lC5BHJ", true)), + Tamil: () => + new UnicodeRangeTable( + decodeRanges( + "i8CBBCFBECBCDBEBBCCCBEEBEEBBBELBFEBECBCDBDHHPUBm+kCxBBOAB", + false, + ), + ), + Tangsa: () => new UnicodeRangeTable(decodeRanges("wz6CuCCJ", true)), + Tangut: () => + new UnicodeRangeTable(decodeRanges("g-7CgBgBB2-FBJ-XBhQIB", false)), + Telugu: () => + new UnicodeRangeTable( + decodeRanges("ggDMBCCBCWBCPBDIBCCBCDBIBBCCBDDDBCBDJBIIB", false), + ), + Thaana: () => new UnicodeRangeTable(decodeRanges("g8BxB", true)), + Thai: () => new UnicodeRangeTable(decodeRanges("hwD5BGb", true)), + Tibetan: () => + new UnicodeRangeTable(decodeRanges("g4DnCCjBFmBCjBCOCGFB", true)), + Tifinagh: () => new UnicodeRangeTable(decodeRanges("wpL3BIBPA", true)), + Tirhuta: () => new UnicodeRangeTable(decodeRanges("gklCnCJJ", true)), + Todhri: () => new UnicodeRangeTable(decodeRanges("guhCzB", true)), + Toto: () => new UnicodeRangeTable(decodeRanges("w04De", true)), + Tulu_Tigalari: () => + new UnicodeRangeTable( + decodeRanges("g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB", false), + ), + Ugaritic: () => new UnicodeRangeTable(decodeRanges("g8gCdCA", true)), + Unknown: () => + new UnicodeRangeTable( + decodeRanges( + "4bBBHDBICCVuMuMnBBBzBBBE4B4BBGBcDBHKBvI9B9BBmDmDBMB8BBByBBBQddBCCMEBgBDDBDBuHJJBDDBXXICCBBBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBbFB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKmDmDNBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBjoIBvLBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCC-FCBHBBHBBHBBECBIIIBIBGBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIBlCJBCBBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMB3iBJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBJ76DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBjGUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEwi3VBCdBhD-DBxHvw-FB", + false, + ), + ), + Vai: () => new UnicodeRangeTable(decodeRanges("gopBrJ", true)), + Vithkuqi: () => + new UnicodeRangeTable(decodeRanges("wrhCKCOCGCBCKCOCGCB", true)), + Wancho: () => new UnicodeRangeTable(decodeRanges("g24D5BGA", true)), + Warang_Citi: () => new UnicodeRangeTable(decodeRanges("glmCyCNA", true)), + Yezidi: () => new UnicodeRangeTable(decodeRanges("g0jCpBCCDB", true)), + Yi: () => new UnicodeRangeTable(decodeRanges("ggoBskBE2B", true)), + Zanabazar_Square: () => new UnicodeRangeTable(decodeRanges("gwmCnC", true)), +}); - // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw - // SyntaxError on these names, so platform sweep is impossible. - private static _NEW_SCRIPTS = - /*#__PURE__*/ new LazyDecoder({ - Garay: () => new UnicodeRangeTable(decodeRanges("gqjClBEcJB", true)), - Gurung_Khema: () => new UnicodeRangeTable(decodeRanges("go4C5B", true)), - Kirat_Rai: () => new UnicodeRangeTable(decodeRanges("gq7C5B", true)), - Ol_Onal: () => new UnicodeRangeTable(decodeRanges("wu5DqBFA", true)), - Sunuwar: () => new UnicodeRangeTable(decodeRanges("g+mChBPJ", true)), - Todhri: () => new UnicodeRangeTable(decodeRanges("guhCzB", true)), - Tulu_Tigalari: () => - new UnicodeRangeTable( - decodeRanges("g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB", false), - ), - }); +const STABLE_CATEGORY_NAMES: ReadonlySet = new Set([ + "C", + "Cc", + "Cf", + "Cn", + "Co", + "Cs", + "L", + "LC", + "Ll", + "Lm", + "Lo", + "Lt", + "Lu", + "M", + "Mc", + "Me", + "Mn", + "N", + "Nd", + "Nl", + "No", + "P", + "Pc", + "Pd", + "Pe", + "Pf", + "Pi", + "Po", + "Ps", + "S", + "Sc", + "Sk", + "Sm", + "So", + "Z", + "Zl", + "Zp", + "Zs", +]); +const STABLE_SCRIPT_NAMES: ReadonlySet = new Set([]); +const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ + "Adlam", + "Ahom", + "Anatolian_Hieroglyphs", + "Arabic", + "Armenian", + "Avestan", + "Balinese", + "Bamum", + "Bassa_Vah", + "Batak", + "Bengali", + "Bhaiksuki", + "Bopomofo", + "Brahmi", + "Braille", + "Buginese", + "Buhid", + "Canadian_Aboriginal", + "Carian", + "Caucasian_Albanian", + "Chakma", + "Cham", + "Cherokee", + "Chorasmian", + "Common", + "Coptic", + "Cuneiform", + "Cypriot", + "Cypro_Minoan", + "Cyrillic", + "Deseret", + "Devanagari", + "Dives_Akuru", + "Dogra", + "Duployan", + "Egyptian_Hieroglyphs", + "Elbasan", + "Elymaic", + "Ethiopic", + "Garay", + "Georgian", + "Glagolitic", + "Gothic", + "Grantha", + "Greek", + "Gujarati", + "Gunjala_Gondi", + "Gurmukhi", + "Gurung_Khema", + "Han", + "Hangul", + "Hanifi_Rohingya", + "Hanunoo", + "Hatran", + "Hebrew", + "Hiragana", + "Imperial_Aramaic", + "Inherited", + "Inscriptional_Pahlavi", + "Inscriptional_Parthian", + "Javanese", + "Kaithi", + "Kannada", + "Katakana", + "Kawi", + "Kayah_Li", + "Kharoshthi", + "Khitan_Small_Script", + "Khmer", + "Khojki", + "Khudawadi", + "Kirat_Rai", + "Lao", + "Latin", + "Lepcha", + "Limbu", + "Linear_A", + "Linear_B", + "Lisu", + "Lycian", + "Lydian", + "Mahajani", + "Makasar", + "Malayalam", + "Mandaic", + "Manichaean", + "Marchen", + "Masaram_Gondi", + "Medefaidrin", + "Meetei_Mayek", + "Mende_Kikakui", + "Meroitic_Cursive", + "Meroitic_Hieroglyphs", + "Miao", + "Modi", + "Mongolian", + "Mro", + "Multani", + "Myanmar", + "Nabataean", + "Nag_Mundari", + "Nandinagari", + "New_Tai_Lue", + "Newa", + "Nko", + "Nushu", + "Nyiakeng_Puachue_Hmong", + "Ogham", + "Ol_Chiki", + "Ol_Onal", + "Old_Hungarian", + "Old_Italic", + "Old_North_Arabian", + "Old_Permic", + "Old_Persian", + "Old_Sogdian", + "Old_South_Arabian", + "Old_Turkic", + "Old_Uyghur", + "Oriya", + "Osage", + "Osmanya", + "Pahawh_Hmong", + "Palmyrene", + "Pau_Cin_Hau", + "Phags_Pa", + "Phoenician", + "Psalter_Pahlavi", + "Rejang", + "Runic", + "Samaritan", + "Saurashtra", + "Sharada", + "Shavian", + "Siddham", + "SignWriting", + "Sinhala", + "Sogdian", + "Sora_Sompeng", + "Soyombo", + "Sundanese", + "Sunuwar", + "Syloti_Nagri", + "Syriac", + "Tagalog", + "Tagbanwa", + "Tai_Le", + "Tai_Tham", + "Tai_Viet", + "Takri", + "Tamil", + "Tangsa", + "Tangut", + "Telugu", + "Thaana", + "Thai", + "Tibetan", + "Tifinagh", + "Tirhuta", + "Todhri", + "Toto", + "Tulu_Tigalari", + "Ugaritic", + "Unknown", + "Vai", + "Vithkuqi", + "Wancho", + "Warang_Citi", + "Yezidi", + "Yi", + "Zanabazar_Square", +]); - static readonly STABLE_CATEGORY_NAMES: ReadonlySet = new Set([ - "C", - "Cc", - "Cf", - "Cn", - "Co", - "Cs", - "L", - "LC", - "Ll", - "Lm", - "Lo", - "Lt", - "Lu", - "M", - "Mc", - "Me", - "Mn", - "N", - "Nd", - "Nl", - "No", - "P", - "Pc", - "Pd", - "Pe", - "Pf", - "Pi", - "Po", - "Ps", - "S", - "Sc", - "Sk", - "Sm", - "So", - "Z", - "Zl", - "Zp", - "Zs", - ]); - static readonly STABLE_SCRIPT_NAMES: ReadonlySet = new Set([ - "Adlam", - "Ahom", - "Anatolian_Hieroglyphs", - "Arabic", - "Armenian", - "Avestan", - "Balinese", - "Bamum", - "Bassa_Vah", - "Batak", - "Bengali", - "Bhaiksuki", - "Bopomofo", - "Brahmi", - "Braille", - "Buginese", - "Buhid", - "Canadian_Aboriginal", - "Carian", - "Caucasian_Albanian", - "Chakma", - "Cham", - "Cherokee", - "Chorasmian", - "Common", - "Coptic", - "Cuneiform", - "Cypriot", - "Cypro_Minoan", - "Cyrillic", - "Deseret", - "Devanagari", - "Dives_Akuru", - "Dogra", - "Duployan", - "Egyptian_Hieroglyphs", - "Elbasan", - "Elymaic", - "Ethiopic", - "Georgian", - "Glagolitic", - "Gothic", - "Grantha", - "Greek", - "Gujarati", - "Gunjala_Gondi", - "Gurmukhi", - "Han", - "Hangul", - "Hanifi_Rohingya", - "Hanunoo", - "Hatran", - "Hebrew", - "Hiragana", - "Imperial_Aramaic", - "Inherited", - "Inscriptional_Pahlavi", - "Inscriptional_Parthian", - "Javanese", - "Kaithi", - "Kannada", - "Katakana", - "Kawi", - "Kayah_Li", - "Kharoshthi", - "Khitan_Small_Script", - "Khmer", - "Khojki", - "Khudawadi", - "Lao", - "Latin", - "Lepcha", - "Limbu", - "Linear_A", - "Linear_B", - "Lisu", - "Lycian", - "Lydian", - "Mahajani", - "Makasar", - "Malayalam", - "Mandaic", - "Manichaean", - "Marchen", - "Masaram_Gondi", - "Medefaidrin", - "Meetei_Mayek", - "Mende_Kikakui", - "Meroitic_Cursive", - "Meroitic_Hieroglyphs", - "Miao", - "Modi", - "Mongolian", - "Mro", - "Multani", - "Myanmar", - "Nabataean", - "Nag_Mundari", - "Nandinagari", - "New_Tai_Lue", - "Newa", - "Nko", - "Nushu", - "Nyiakeng_Puachue_Hmong", - "Ogham", - "Ol_Chiki", - "Old_Hungarian", - "Old_Italic", - "Old_North_Arabian", - "Old_Permic", - "Old_Persian", - "Old_Sogdian", - "Old_South_Arabian", - "Old_Turkic", - "Old_Uyghur", - "Oriya", - "Osage", - "Osmanya", - "Pahawh_Hmong", - "Palmyrene", - "Pau_Cin_Hau", - "Phags_Pa", - "Phoenician", - "Psalter_Pahlavi", - "Rejang", - "Runic", - "Samaritan", - "Saurashtra", - "Sharada", - "Shavian", - "Siddham", - "SignWriting", - "Sinhala", - "Sogdian", - "Sora_Sompeng", - "Soyombo", - "Sundanese", - "Syloti_Nagri", - "Syriac", - "Tagalog", - "Tagbanwa", - "Tai_Le", - "Tai_Tham", - "Tai_Viet", - "Takri", - "Tamil", - "Tangsa", - "Tangut", - "Telugu", - "Thaana", - "Thai", - "Tibetan", - "Tifinagh", - "Tirhuta", - "Toto", - "Ugaritic", - "Unknown", - "Vai", - "Vithkuqi", - "Wancho", - "Warang_Citi", - "Yezidi", - "Yi", - "Zanabazar_Square", - ]); - static readonly NEW_SCRIPT_NAMES: ReadonlySet = new Set([ - "Garay", - "Gurung_Khema", - "Kirat_Rai", - "Ol_Onal", - "Sunuwar", - "Todhri", - "Tulu_Tigalari", - ]); +const _sweepCache = new Map(); +const _foldCache = new Map(); - private static _sweepCache = new Map(); - private static _foldCache = new Map(); +// Returns the base range table for a property name, or null if unknown. +// Stable names: platform sweep + bundled delta (15.0 → 16.0). +// New-in-16.0 script names: bundled full table. +const buildForProperty = (name: string): UnicodeRangeTable | null => { + if (NEW_SCRIPT_NAMES.has(name)) { + return _NEW_SCRIPTS.get(name); + } + let kind: "category" | "script" | null = null; + let pattern: string | null = null; + if (STABLE_CATEGORY_NAMES.has(name)) { + kind = "category"; + pattern = `\\p{General_Category=${name}}`; + } else if (STABLE_SCRIPT_NAMES.has(name)) { + kind = "script"; + pattern = `\\p{Script=${name}}`; + } else return null; - // Returns the base range table for a property name, or null if unknown. - // Stable names: platform sweep + bundled delta (15.0 → 16.0). - // New-in-16.0 script names: bundled full table. - static buildForProperty(name: string): UnicodeRangeTable | null { - if (this.NEW_SCRIPT_NAMES.has(name)) { - return this._NEW_SCRIPTS.get(name); - } - let kind: "category" | "script" | null = null; - let pattern: string | null = null; - if (this.STABLE_CATEGORY_NAMES.has(name)) { - kind = "category"; - pattern = `\\p{General_Category=${name}}`; - } else if (this.STABLE_SCRIPT_NAMES.has(name)) { - kind = "script"; - pattern = `\\p{Script=${name}}`; - } else return null; + const cacheKey = `${kind}:${name}`; + const cached = _sweepCache.get(cacheKey); + if (cached) return cached; - const cacheKey = `${kind}:${name}`; - const cached = this._sweepCache.get(cacheKey); - if (cached) return cached; + const base = sweepPlatform(pattern); + const delta = + kind === "category" + ? _DELTA_CATEGORIES.get(name) + : _DELTA_SCRIPTS.get(name); + const merged = delta ? mergeRanges(base, delta) : base; + const table = new UnicodeRangeTable(merged); + _sweepCache.set(cacheKey, table); + return table; +}; - const base = sweepPlatform(pattern); - const delta = - kind === "category" - ? this._DELTA_CATEGORIES.get(name) - : this._DELTA_SCRIPTS.get(name); - const merged = delta ? mergeRanges(base, delta) : base; - const table = new UnicodeRangeTable(merged); - this._sweepCache.set(cacheKey, table); - return table; +// Computes the fold-overlay for a property name: additional runes that +// fold to some rune already in the base class. Returns null if no overlay +// is needed (base class is fold-stable). +const buildFoldOverlay = (name: string): UnicodeRangeTable | null => { + const cached = _foldCache.get(name); + if (cached !== undefined) return cached; + const base = buildForProperty(name); + if (!base) { + _foldCache.set(name, null); + return null; } - - // Computes the fold-overlay for a property name: additional runes that - // fold to some rune already in the base class. Returns null if no overlay - // is needed (base class is fold-stable). - static buildFoldOverlay(name: string): UnicodeRangeTable | null { - const cached = this._foldCache.get(name); - if (cached !== undefined) return cached; - const base = this.buildForProperty(name); - if (!base) { - this._foldCache.set(name, null); - return null; + const inBase = (r: number): boolean => { + let lo = 0, + hi = base.length; + while (lo < hi) { + const m = (lo + hi) >> 1; + const rlo = base.getLo(m), + rhi = base.getHi(m); + if (r < rlo) hi = m; + else if (r > rhi) lo = m + 1; + else return (r - rlo) % base.getStride(m) === 0; } - const inBase = (r: number): boolean => { - let lo = 0, - hi = base.length; - while (lo < hi) { - const m = (lo + hi) >> 1; - const rlo = base.getLo(m), - rhi = base.getHi(m); - if (r < rlo) hi = m; - else if (r > rhi) lo = m + 1; - else return (r - rlo) % base.getStride(m) === 0; - } - return false; - }; - // Inline simpleFold to avoid circular import with Unicode.ts. - const orbit = UnicodeTables.CASE_ORBIT; - const simpleFold = (r: number): number => { - if (orbit.has(r)) return orbit.get(r)!; - const s = String.fromCodePoint(r); - const lower = s.toLowerCase(); - if (lower.length === s.length) { - const lowerCp = lower.codePointAt(0)!; - if (lowerCp !== r) return lowerCp; - } - const upper = s.toUpperCase(); - if (upper.length === s.length) { - const upperCp = upper.codePointAt(0)!; - if (upperCp !== r) return upperCp; - } - return r; - }; - const extras = new Set(); - for (let i = 0; i < base.length; i++) { - const lo = base.getLo(i), - hi = base.getHi(i), - stride = base.getStride(i); - for (let cp = lo; cp <= hi; cp += stride) { - let r = simpleFold(cp); - while (r !== cp) { - if (!inBase(r)) extras.add(r); - r = simpleFold(r); - } - } - } - if (extras.size === 0) { - this._foldCache.set(name, null); - return null; + return false; + }; + // Inline simpleFold to avoid circular import with Unicode.ts. + const orbit = getCASE_ORBIT(); + const simpleFold = (r: number): number => { + const folded = orbit.get(r); + if (folded !== undefined) return folded; + const s = String.fromCodePoint(r); + const lower = s.toLowerCase(); + if (lower.length === s.length) { + const lowerCp = lower.codePointAt(0); + if (lowerCp !== undefined && lowerCp !== r) return lowerCp; } - const sorted = Array.from(extras).sort((a, b) => a - b); - const merged: [number, number][] = []; - for (const cp of sorted) { - const last = merged[merged.length - 1]; - if (last && last[1] + 1 === cp) last[1] = cp; - else merged.push([cp, cp]); + const upper = s.toUpperCase(); + if (upper.length === s.length) { + const upperCp = upper.codePointAt(0); + if (upperCp !== undefined && upperCp !== r) return upperCp; } - const out = new Uint32Array(merged.length * 3); - for (let i = 0; i < merged.length; i++) { - out[i * 3] = merged[i][0]; - out[i * 3 + 1] = merged[i][1]; - out[i * 3 + 2] = 1; + return r; + }; + const extras = new Set(); + for (let i = 0; i < base.length; i++) { + const lo = base.getLo(i), + hi = base.getHi(i), + stride = base.getStride(i); + for (let cp = lo; cp <= hi; cp += stride) { + let r = simpleFold(cp); + while (r !== cp) { + if (!inBase(r)) extras.add(r); + r = simpleFold(r); + } } - const table = new UnicodeRangeTable(out); - this._foldCache.set(name, table); - return table; } + if (extras.size === 0) { + _foldCache.set(name, null); + return null; + } + const sorted = Array.from(extras).sort((a, b) => a - b); + const merged: [number, number][] = []; + for (const cp of sorted) { + const last = merged[merged.length - 1]; + if (last && last[1] + 1 === cp) last[1] = cp; + else merged.push([cp, cp]); + } + const out = new Uint32Array(merged.length * 3); + for (let i = 0; i < merged.length; i++) { + out[i * 3] = merged[i][0]; + out[i * 3 + 1] = merged[i][1]; + out[i * 3 + 2] = 1; + } + const table = new UnicodeRangeTable(out); + _foldCache.set(name, table); + return table; +}; - // --- Legacy API surface used by Parser --- - - static CATEGORIES = { - has: (name: string): boolean => - UnicodeTables.STABLE_CATEGORY_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => - UnicodeTables.buildForProperty(name), - }; +const getUpper = (): UnicodeRangeTable => { + const table = buildForProperty("Lu"); + if (table === null) { + throw new Error("Upper: missing Lu property"); + } + return table; +}; - static SCRIPTS = { - has: (name: string): boolean => - UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || - UnicodeTables.NEW_SCRIPT_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => - UnicodeTables.buildForProperty(name), - }; +// --- Legacy API surface used by Parser --- - static FOLD_CATEGORIES = { +export const UnicodeTables = { + get CASE_ORBIT(): Map { + return getCASE_ORBIT(); + }, + STABLE_CATEGORY_NAMES, + STABLE_SCRIPT_NAMES, + NEW_SCRIPT_NAMES, + buildForProperty, + buildFoldOverlay, + CATEGORIES: { + has: (name: string): boolean => STABLE_CATEGORY_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => buildForProperty(name), + }, + SCRIPTS: { has: (name: string): boolean => - UnicodeTables.STABLE_CATEGORY_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => - UnicodeTables.buildFoldOverlay(name), - }; - - static FOLD_SCRIPT = { + STABLE_SCRIPT_NAMES.has(name) || NEW_SCRIPT_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => buildForProperty(name), + }, + FOLD_CATEGORIES: { + has: (name: string): boolean => STABLE_CATEGORY_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => buildFoldOverlay(name), + }, + FOLD_SCRIPT: { has: (name: string): boolean => - UnicodeTables.STABLE_SCRIPT_NAMES.has(name) || - UnicodeTables.NEW_SCRIPT_NAMES.has(name), - get: (name: string): UnicodeRangeTable | null => - UnicodeTables.buildFoldOverlay(name), - }; - - static get Upper(): UnicodeRangeTable { - return UnicodeTables.buildForProperty("Lu")!; - } -} - -export { UnicodeTables }; + STABLE_SCRIPT_NAMES.has(name) || NEW_SCRIPT_NAMES.has(name), + get: (name: string): UnicodeRangeTable | null => buildFoldOverlay(name), + }, + get Upper(): UnicodeRangeTable { + return getUpper(); + }, +}; diff --git a/packages/re2/src/Utils.ts b/packages/re2/src/Utils.ts index 1f0e870..668e384 100644 --- a/packages/re2/src/Utils.ts +++ b/packages/re2/src/Utils.ts @@ -1,4 +1,5 @@ import { MAX_BMP } from "./Unicode.js"; +import { codePointAtOrThrow } from "./__utils__/chars.js"; /** * Various constants and helper utilities. @@ -42,7 +43,7 @@ function unhex(c: number): number { // Returns the array of runes in the specified UTF-16 string. function stringToRunes(str: string): number[] { - return Array.from(String(str)).map((s) => s.codePointAt(0)!); + return Array.from(String(str)).map((s) => codePointAtOrThrow(s, 0)); } // Returns the Java UTF-16 string containing the single rune |r|. diff --git a/packages/re2/src/__tests__/BugHunt.test.ts b/packages/re2/src/__tests__/BugHunt.test.ts index 20b5fe7..c971b2e 100644 --- a/packages/re2/src/__tests__/BugHunt.test.ts +++ b/packages/re2/src/__tests__/BugHunt.test.ts @@ -15,24 +15,14 @@ describe("bug-hunt verification", () => { test("executeEngine with ANCHOR_START and pos>0 finds substring match", () => { const re = RE2JS.compile("abc"); const input = fromUTF16("xyzabc"); - const result = (re as any).re2Input.executeEngine( - input, - 3, - ANCHOR_START, - 0, - ); + const result = re.re2Input.executeEngine(input, 3, ANCHOR_START, 0); assert.notStrictEqual(result, null); }); test("executeEngine with ANCHOR_START and pos>0 where pattern does not start at pos", () => { const re = RE2JS.compile("abc"); const input = fromUTF16("xyzabc"); - const result = (re as any).re2Input.executeEngine( - input, - 1, - ANCHOR_START, - 0, - ); + const result = re.re2Input.executeEngine(input, 1, ANCHOR_START, 0); assert.strictEqual(result, null); }); diff --git a/packages/re2/src/__tests__/CharClass.test.ts b/packages/re2/src/__tests__/CharClass.test.ts index 78641bf..b0f8bd0 100644 --- a/packages/re2/src/__tests__/CharClass.test.ts +++ b/packages/re2/src/__tests__/CharClass.test.ts @@ -1,7 +1,7 @@ import { describe, test } from "node:test"; import * as assert from "node:assert/strict"; import { FOLD_CASE } from "../RE2Flags.js"; -import { CharGroup, getPerlGroups } from "../CharGroup.js"; +import { type CharGroup, getPerlGroups } from "../CharGroup.js"; import { CharClass } from "../CharClass.js"; import { MAX_FOLD, MAX_RUNE } from "../Unicode.js"; import { UnicodeRangeTable } from "../UnicodeRangeTable.js"; @@ -284,13 +284,17 @@ describe(".appendNegatedTable", () => { }); describe(".appendGroup", () => { + const perlGroups = getPerlGroups(); + const getGroup = (name: string): CharGroup => { + const group = perlGroups.get(name); + if (group === undefined) { + throw new Error(`perl group not found: ${name}`); + } + return group; + }; const cases: [number[], CharGroup, number[]][] = [ - [[], getPerlGroups().get("\\d")!, ["0", "9"].map(codePoint)], - [ - [], - getPerlGroups().get("\\D")!, - [0, codePoint("/"), codePoint(":"), MAX_RUNE], - ], + [[], getGroup("\\d"), ["0", "9"].map(codePoint)], + [[], getGroup("\\D"), [0, codePoint("/"), codePoint(":"), MAX_RUNE]], ]; for (let i = 0; i < cases.length; i++) { diff --git a/packages/re2/src/__tests__/Exec.test.ts b/packages/re2/src/__tests__/Exec.test.ts index fc28198..4b21e31 100644 --- a/packages/re2/src/__tests__/Exec.test.ts +++ b/packages/re2/src/__tests__/Exec.test.ts @@ -9,6 +9,7 @@ import url from "node:url"; import { RE2 } from "../RE2.js"; import { CLASS_NL, FOLD_CASE, POSIX } from "../RE2Flags.js"; import { quoteMeta } from "../Utils.js"; +import { codePoint, codePointAtOrThrow } from "../__utils__/chars.js"; const FIXTURES_DIRNAME = path.join( path.dirname(url.fileURLToPath(import.meta.url)), @@ -17,7 +18,7 @@ const FIXTURES_DIRNAME = path.join( const isSingleBytes = (s: string): boolean => { for (let i = 0; i < s.length; i++) { - if (s.codePointAt(i)! >= 0x80) { + if (codePointAtOrThrow(s, i) >= 0x80) { return false; } } @@ -116,15 +117,12 @@ const testRE2 = async (fileName: string): Promise => { } const first = line.charAt(0); - const firstCodePoint = first.codePointAt(0)!; + const firstCodePoint = codePoint(first); if (first === "#") { continue; } - if ( - "A".codePointAt(0)! <= firstCodePoint && - firstCodePoint <= "Z".codePointAt(0)! - ) { + if (codePoint("A") <= firstCodePoint && firstCodePoint <= codePoint("Z")) { continue; } @@ -182,8 +180,7 @@ const testRE2 = async (fileName: string): Promise => { input = 0; } else if ( first === "-" || - ("0".codePointAt(0)! <= firstCodePoint && - firstCodePoint <= "9".codePointAt(0)!) + (codePoint("0") <= firstCodePoint && firstCodePoint <= codePoint("9")) ) { if (re === null) { continue; @@ -231,12 +228,12 @@ const testRE2 = async (fileName: string): Promise => { const parseFowlerResult = (s: string): [number[], boolean[]] => { if (s.length === 0) { return [[], [true, true]]; - } else if (s === "NOMATCH") { + } + if (s === "NOMATCH") { return [[], [true, false]]; - } else if ( - "A".codePointAt(0)! <= s.codePointAt(0)! && - s.codePointAt(0)! <= "Z".codePointAt(0)! - ) { + } + const firstCp = codePoint(s); + if (codePoint("A") <= firstCp && firstCp <= codePoint("Z")) { return [[], [false, false]]; } @@ -292,7 +289,6 @@ const testFowler = async (fileName: string): Promise => { field[i] = ""; } if (field[i] === "NIL") { - continue; } } @@ -362,12 +358,13 @@ const testFowler = async (fileName: string): Promise => { let flags = POSIX | CLASS_NL; switch (flag.charAt(i)) { - default: - continue; case "E": break; case "L": pattern = quoteMeta(pattern); + break; + default: + continue; } if (flag.indexOf("i") >= 0) { diff --git a/packages/re2/src/__tests__/Inst.test.ts b/packages/re2/src/__tests__/Inst.test.ts index bb2e351..cc98774 100644 --- a/packages/re2/src/__tests__/Inst.test.ts +++ b/packages/re2/src/__tests__/Inst.test.ts @@ -2,6 +2,7 @@ import { describe, it } from "node:test"; import * as assert from "node:assert/strict"; import { Inst } from "../Inst.js"; import { FOLD_CASE } from "../RE2Flags.js"; +import { codePoint } from "../__utils__/chars.js"; describe("Inst.matchRune Array Search Logic", () => { it("correctly matches using the linear search fast-path (length 4)", () => { @@ -39,11 +40,11 @@ describe("Inst.matchRune Array Search Logic", () => { it("correctly handles case-folding single runes", () => { const inst = new Inst(Inst.RUNE); - inst.runes = ["a".codePointAt(0)!]; + inst.runes = [codePoint("a")]; inst.arg = FOLD_CASE; - assert.strictEqual(inst.matchRune("a".codePointAt(0)!), true); - assert.strictEqual(inst.matchRune("A".codePointAt(0)!), true); - assert.strictEqual(inst.matchRune("b".codePointAt(0)!), false); + assert.strictEqual(inst.matchRune(codePoint("a")), true); + assert.strictEqual(inst.matchRune(codePoint("A")), true); + assert.strictEqual(inst.matchRune(codePoint("b")), false); }); }); diff --git a/packages/re2/src/__tests__/Unicode.test.ts b/packages/re2/src/__tests__/Unicode.test.ts index 57bc1dd..297f106 100644 --- a/packages/re2/src/__tests__/Unicode.test.ts +++ b/packages/re2/src/__tests__/Unicode.test.ts @@ -76,7 +76,8 @@ describe("#equalsIgnoreCase", () => { describe("UnicodeTables VLQ Decompression", () => { it("should decompress the Zl (Line Separator) table correctly", () => { - const zlTable = UnicodeTables.CATEGORIES.get("Zl")!; + const zlTable = UnicodeTables.CATEGORIES.get("Zl"); + assert.ok(zlTable, "Zl category table missing"); assert.strictEqual(zlTable.length, 1); assert.strictEqual(zlTable.getLo(0), 0x2028); @@ -85,7 +86,8 @@ describe("UnicodeTables VLQ Decompression", () => { }); it("should decompress the Zp (Paragraph Separator) table correctly", () => { - const zpTable = UnicodeTables.CATEGORIES.get("Zp")!; + const zpTable = UnicodeTables.CATEGORIES.get("Zp"); + assert.ok(zpTable, "Zp category table missing"); assert.strictEqual(zpTable.length, 1); assert.strictEqual(zpTable.getLo(0), 0x2029); @@ -111,7 +113,8 @@ describe("UnicodeTables VLQ Decompression", () => { }); it("should decompress the Nd (Decimal Digits) table correctly with strides", () => { - const ndTable = UnicodeTables.CATEGORIES.get("Nd")!; + const ndTable = UnicodeTables.CATEGORIES.get("Nd"); + assert.ok(ndTable, "Nd category table missing"); assert.ok(ndTable.length > 0); diff --git a/packages/re2/src/__tests__/index.test.ts b/packages/re2/src/__tests__/index.test.ts index 2105f0d..bf0e6c8 100644 --- a/packages/re2/src/__tests__/index.test.ts +++ b/packages/re2/src/__tests__/index.test.ts @@ -1,7 +1,7 @@ import { describe, test, it } from "node:test"; import * as assert from "node:assert/strict"; import { RE2JS } from "../index.js"; -import { RE2JSSyntaxException } from "../exceptions.js"; +import type { RE2JSSyntaxException } from "../exceptions.js"; it("compile", () => { const p = RE2JS.compile("abc"); @@ -43,12 +43,12 @@ it("syntax error", () => { } assert.notStrictEqual(error, null); - assert.strictEqual(error!.getDescription(), "missing closing )"); + assert.strictEqual(error?.getDescription(), "missing closing )"); assert.strictEqual( - error!.message, + error?.message, "error parsing regexp: missing closing ): `abc(`", ); - assert.strictEqual(error!.getPattern(), "abc("); + assert.strictEqual(error?.getPattern(), "abc("); }); describe("matches no flags", () => { diff --git a/packages/re2/src/__tests__/stability.test.ts b/packages/re2/src/__tests__/stability.test.ts index 73fa7fb..7b3be80 100644 --- a/packages/re2/src/__tests__/stability.test.ts +++ b/packages/re2/src/__tests__/stability.test.ts @@ -77,7 +77,7 @@ describe("RE2JS Stability and Anti-ReDoS Guarantees", () => { }); describe("NFA Fallback Correctness (DFA state explosion)", () => { - const forceNfaFallback = (regexStr: string, flags: number = 0) => { + const forceNfaFallback = (regexStr: string, flags = 0) => { const re = RE2JS.compile(regexStr, flags); re.re2Input.dfa.failed = true; return re; diff --git a/packages/re2/src/__utils__/chars.ts b/packages/re2/src/__utils__/chars.ts index 1401ef8..e9e53ec 100644 --- a/packages/re2/src/__utils__/chars.ts +++ b/packages/re2/src/__utils__/chars.ts @@ -1 +1,17 @@ -export const codePoint = (v: string): number => v.codePointAt(0)!; +export const codePoint = (v: string): number => { + const cp = v.codePointAt(0); + if (cp === undefined) { + throw new Error("codePoint: empty string"); + } + return cp; +}; + +export const codePointAtOrThrow = (s: string, i: number): number => { + const cp = s.codePointAt(i); + if (cp === undefined) { + throw new Error( + `codePointAt(${i}) returned undefined for ${JSON.stringify(s)}`, + ); + } + return cp; +}; diff --git a/packages/re2/src/__utils__/parser.ts b/packages/re2/src/__utils__/parser.ts index 5748677..7292f81 100644 --- a/packages/re2/src/__utils__/parser.ts +++ b/packages/re2/src/__utils__/parser.ts @@ -29,7 +29,7 @@ export const dumpRegexp = (re: Regexp): string => { if (!OP_NAMES.has(re.op)) { b += `op${re.op}`; } else { - const name = OP_NAMES.get(re.op)!; + const name = OP_NAMES.get(re.op) as string; switch (re.op) { case Regexp.Op.STAR: From 6554cea72fbf5053eb4a7615e3982e68a99010c7 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Mon, 20 Apr 2026 17:05:11 -0400 Subject: [PATCH 08/13] add test to validate unicode range tables. fix delta ranges in UnicodeTables.ts --- package-lock.json | 8 + packages/re2/package.json | 1 + packages/re2/scripts/genUnicodeTable.js | 11 + packages/re2/src/UnicodeTables.ts | 466 ++---------------- .../__tests__/UnicodeTableContents.test.ts | 175 +++++++ 5 files changed, 248 insertions(+), 413 deletions(-) create mode 100644 packages/re2/src/__tests__/UnicodeTableContents.test.ts diff --git a/package-lock.json b/package-lock.json index 5bf6f68..9c31925 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1044,6 +1044,13 @@ "typescript": "*" } }, + "node_modules/@unicode/unicode-15.0.0": { + "version": "1.6.16", + "resolved": "https://registry.npmjs.org/@unicode/unicode-15.0.0/-/unicode-15.0.0-1.6.16.tgz", + "integrity": "sha512-Ca38T4Hv/+CeUoOX4Oowm/0+OONr0sV0GqzLCzL/lo9AbxX6wweco55lNwOJJyB7v7bYKq+oBizINOlXbsjY8Q==", + "dev": true, + "license": "MIT" + }, "node_modules/@unicode/unicode-16.0.0": { "version": "1.6.16", "resolved": "https://registry.npmjs.org/@unicode/unicode-16.0.0/-/unicode-16.0.0-1.6.16.tgz", @@ -2095,6 +2102,7 @@ "version": "0.4.0", "license": "MIT", "devDependencies": { + "@unicode/unicode-15.0.0": "^1.6.16", "@unicode/unicode-16.0.0": "^1.6.16", "unicode-property-value-aliases": "^3.9.0" } diff --git a/packages/re2/package.json b/packages/re2/package.json index fcd2308..08fc3d4 100644 --- a/packages/re2/package.json +++ b/packages/re2/package.json @@ -42,6 +42,7 @@ } }, "devDependencies": { + "@unicode/unicode-15.0.0": "^1.6.16", "@unicode/unicode-16.0.0": "^1.6.16", "unicode-property-value-aliases": "^3.9.0" } diff --git a/packages/re2/scripts/genUnicodeTable.js b/packages/re2/scripts/genUnicodeTable.js index 52c650d..ed67625 100644 --- a/packages/re2/scripts/genUnicodeTable.js +++ b/packages/re2/scripts/genUnicodeTable.js @@ -1,5 +1,9 @@ import { CodepointRange } from "./codepointRange.js"; import unicode16 from "@unicode/unicode-16.0.0"; +// Imported for its side effect of being a declared devDependency. +// loadCodePoints() below dynamically imports `@unicode/unicode-15.0.0///code-points.js` +// paths, and requires the package to be installed. +import "@unicode/unicode-15.0.0"; import CommonCaseFolding from "@unicode/unicode-16.0.0/Case_Folding/C/code-points.js"; import SimpleCaseFolding from "@unicode/unicode-16.0.0/Case_Folding/S/code-points.js"; import unicodePropertyValueAliases from "unicode-property-value-aliases"; @@ -513,6 +517,13 @@ const code = [ " get: (name: string): UnicodeRangeTable | null => buildFoldOverlay(name),", " },", " get Upper(): UnicodeRangeTable { return getUpper() },", + "", + " // --- Test-only hooks: expose the raw bundled 15.0→16.0 delta and", + " // new-in-16.0 script data so tests can verify the generator output.", + " // These are not part of the public API.", + " _deltaCategoryRanges: (name: string): Uint32Array | null => _DELTA_CATEGORIES.get(name),", + " _deltaScriptRanges: (name: string): Uint32Array | null => _DELTA_SCRIPTS.get(name),", + " _newScriptTable: (name: string): UnicodeRangeTable | null => _NEW_SCRIPTS.get(name),", "}", "", ]; diff --git a/packages/re2/src/UnicodeTables.ts b/packages/re2/src/UnicodeTables.ts index 0753935..7f23ef1 100644 --- a/packages/re2/src/UnicodeTables.ts +++ b/packages/re2/src/UnicodeTables.ts @@ -156,448 +156,77 @@ const getCASE_ORBIT = (): Map => { // Additions from Unicode 15.0 → 16.0 per stable general-category name. // Merged unconditionally with platform sweep output; no-op on 16.0+ engines. const _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({ - C: () => - decodeRanges( - "AfBgDgBBOrWrWBHHBCBICCVuMuMnBBBzBBBE4B4BBGBcDBHQBXhGhGxBBB8BBBmDNB8BBByBBBQddBCCMEBgBHBsCiFiFJBBDBBXIICCBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBPMMBEB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKMMBDBbEByBPBDBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBjoIBvLBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCB-FCBHBBHBBHBBECBIIIBLBDBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIB-BGGBLBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMBxhBPBXJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBF-6DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBrCHBxDUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEvq3VBxHvw-FB", - false, - ), - Cc: () => decodeRanges("AfgDgB", true), - Cf: () => - decodeRanges( - "tFzqBzqBBEBXhGhGyBhMhMBxCxCs5D9-B9-BBDBbEByBEBCJBw03B6H6HBBBimEQQj7IPBhjiBDBwmFHBn0rYffB+CB", - false, - ), - Cn: () => - decodeRanges( - "4bBBHDBICCVuMuMnBBBzBBBE4B4BBGBcDBHKBvI9B9BBmDmDBMB8BBByBBBQddBCCMEBgBDDBDBuHJJBDDBXXICCBBBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBbFB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKmDmDNBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBDBvzIBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCC-FCBHBBHBBHBBECBIIIBIBGBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIBlCJBCBBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMB3iBJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBJ76DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBjGUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEwi3VBCdBhD-DBxHvw-BB---BBB---BBB", - false, - ), - Co: () => decodeRanges("gg4B-nGh4hc9--BD9--B", true), - Cs: () => decodeRanges("gg2B--B", true), L: () => decodeRanges( - "hCZBHZBwBLLFGGBVBCeBCpOBFLBPEBICCiEEBCBBDDBCHHCCBCCCBSBCyCBCqEBJlFBClBBDHHBnBBoCaBFDBuBqBBkBBBCiDBCQQBIIBLLBBBDRRCdBe4CBMZZBfBKBBFGGBUBFKKEYYBXBIKBGXBCFBSpBB7B1BBETTIJBQPBFHBDBBDVBCGBCEEBCBERROBBCCBPBBLJJBEBFBBDVBCGBCBBCBBCBBgBDBCUUBBBRIBCCBCVBCGBCBBCEBETTQBBYMMBGBDBBDVBCGBCBBCEBEffBCCBBBQSSCFBECBCDBEBBCCCBEEBEEBBBELBX1B1BBGBCCBCWBCPBEbbBBBDDDBffFHBCCBCWBCJBCEBEgBgBBCCBQQBSSBHBCCBCoBBDRRGCBJCBZFBGRBEXBCIBCDDBFB7BvBBCBBNGB7BBBCCCBDBCXBCCCBIBCBBKDDBDBCWWBCBhBgCgCBGBCjBBcEB0DqBBVRRBEBFDBEEEBIIBBBFMBNSSBkBBCGGDqBBCsKBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBmBPBR1CBDFBErTBDQBCZBGqCBHHBIRBOSBPRBPMBCCBQzBBkBFFkC4CBIEBDhBBCGGBkCBLeByBdBDEBMrBBFZB3BWBK0BBzC+C+CBtBBSHB3BdBOBBLrBBbjBBqBCBLjBBDKBGqBBDCBqBDBCFBCBBEGGB+FBhC1IBDFBDlBBDFBDHBCGCBdBD0BBCGBCEEBBBCGBEDBDFBFMBGCBCGB1DOORMBmDFFDJBCEEBDBHGCBCBCKBDDBGEBF1B1BB8zC8zCBjHBHDBEBBNlBBCGGD3BBIRRBVBKGBCGBCGBCGBCGBCGBCGBCGBxC2O2OBrBrBBDBGBBF1CBHCBC5CBCDBGqBBC9CBSfBxBPBhQ-tGBhCs0VBkCtBBDsIBEPBLBBVuBBReBDlCByBIBDmDBDiCBDBBCCCBGBWPBCCBCDBCWBezBBPxBB-BFBECCBMMBaBLWBacBIuBBdRRBDBCJBLEBCoBBYCBCHBVWBEEEBwBBCEEBDDBDBDCCZCBDKBICBNFBDFBDFBKGBCGBCqBBCNBHyDBej9KBNWBFwBBloItLBDpDBnBGBNEBGCCBIBCMBCEBCCCBCCBCCBqDBiBqLBT-BBD1BBpBLB1DEBCmEBlBZBHZBM4CBEFBDFBDFBDCBkBLBCZBCSBCBBCOBDNBjB6DBmMcBEwBBwBfBOTBCHBHlBBLdBDjBBFHBxB9EBTjBBFjBBFnBBJzBBNKBCOBCGBCBBCKBCOBCGBCBBEzBBN2JBKVBLHBZFBCpBBCIBmCFBDCCBqBBCBBEDDBVBLWBKeBiCSBCBBLVBLZBnC3BBHBBhCQQBCBCCBCcBrBcBEcBkBHBCbBc1BBLVBLSBORBvDoCB4ByBBOyBBOjBBnBbBKWB7HpBBHBBRCB8BcBLJJBUBrBRBvBUBcWBN0BB6BBBDOOBrBBhBYBbjBBeDDJiBBENNBuBBPDBWCCkBRBCYBUBBgCGBCCCBCBCOBCJBIuBBnBHBDBBDVBCGBCBBCEBETTNEBfJBCDDClBBCaaCtBtBBzBBTDBVCBfvBBVBBC5F5FBtBBqBDBlBvBBV8B8BBpBBOoCoCBZBmBGB6FrBB1D-BBgBHBDDDBGBCBBCXBQCC-CHBDmBBRCCdLLBmBBIWWMtBBUTTBnCBoGgBBgBIBCkBBSyByBBcBxDGBCBBClBBWaaBEBCBBCfBPoKoKBRBQCCBLBChBB9DwCwCB4cBnHjGBtyCgDBQvhBBSFBa68DBGmSB61GdBj3B4RBIeBSuCBSdBTvBBRDBgBUBGSBxNsBB0G-BBhEqCBGjCjCBLBhCBBCddB2-FBJ1mBBqBJBo3IDBCGBCBBCiJBQeeBBBDPPBCBJrMBloCqDBGMBEIBIJBn7F0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDYBCYBCeBCYBCeBCYBCeBCYBCeBCYBCHB15BeBHFBmI9BBzEsBBLGBRiKiKBcBTrBBlPbBlHdBDwPwPBFBCDBCBBCOBCkGB8BjCBI1lB1lBBCBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQBlqE-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB", - false, - ), - LC: () => - decodeRanges( - "hCZBHZB7BLLBVBCeBCiGBCDBFvGBCaBhGDBDBBECBCHHCCBCCCBSBCyCBCqEBJlFBClBBKoBB44ClBBCGGDqBBDCBhV1CBDFBjkCKBGqBBDCBhCrBBgCMBChBBmD1IBDFBDlBBDFBDHBCGCBdBD0BBCGBCEEBBBCGBEDBDFBFMBGCBCGBmIFFDJBCEEBDBHGCBCBCFBFDDBCBGEBF1B1BB8zC8zCB6DBDmDBHDBEBBNlBBCGGzoetBBTbBnEtCBCWBEDBC9BBDBBCCCBGBZBBE2Z2ZBpBBGIBIvCBh6TGBNEBqgBZBHZBmlBvCBhDjBBFjBB1DKBCOBCGBCBBCKBCOBCGBCBBk2ByBBOyBB+CVBLVB74C-BBhrV-BBhsZ0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDYBCYBCeBCYBCeBCYBCeBCYBCeBCYBCHB15BJBCTBHFB2uCjCB", - false, - ), - Ll: () => - decodeRanges( - "hDZB7BqBqBBWBCHBC2BCBQCBuBCDECBBBDCCDEEBFFDEEBBBDDDCCCDCCBCCDEECDDBDDBBBHGDCOCBSCBDDCEEC4BCBFBDDDBCCFICBjCBCaBiGCCEEEBBBTccBhBBCBBECBCWCBDBCGDB0B0BBuBBCgBCK0BCDMCBgDCxBoBBo6CqBBDCB5XFBjkCIBC2D2DBqBBgCMBChBBnD0ECBHBCgDCBHBJFBLHBJHBJFBLHBJHBJNBDHBJHBJHBJEBCBBHEEBBBCBBJDBDBBJHBLCBCBBzIEEBEEcKFDBBJDBF2B2Bs1CvBBCEEBGCFCCBCCBEBGiDCBIICFFNlBBCGG0oesBCUaCoEMCBBBC+BCBGBCCCDICFCCDCCBBBCSCGGGCMCFCCDEECICbEE2ZqBBGIBIvCBh6TGBNEBqhBZBumBnBBpEjBB8EKBCOBCGBCBBk4ByBB+DVB75CfBhsVfB7sZZBbGBCRBbZBbDBCCCBFBCKBbZBbZBbZBbZBbZBbZBbZBbZBbbBdYBCFBbYBCFBbYBCFBbYBCFBbYBCFBC15B15BBIBCTBHFB4vChBB", - false, - ), - Lm: () => - decodeRanges( - "wVRBFLBPEBICCmEGG-OnHnHlFBBuIBBFgBgBKEEhFoFoF1mBgEgE2R72B72BsDkTkTxOFBvF+BBOjBjBBjBByVOORMBg-CBByHgGgG2OsBsBBDBGiDiDB+C+CBBB34bjnBjnBBEBvIzDzDdBB6DIBxCYYqDCBEBB2OXXqEtDtDWBBoDDBKngVngVuBBBh-BFBCpBBCIB0sBhBhBxuXDB9PCBpBBBnRMBhCBBCtgQtgQBCBCGBCBByhM9BBqGGBudgjBgjB", + "pkHBBh6iBCBNCBkvXzBB36BbBKWB9JCB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBjhDsBBz8HxmWxmWBcBDgwhCgwhCBsTB", false, ), + LC: () => decodeRanges("pkHBh6iBCNC0rZVLV", true), + Ll: () => decodeRanges("qkHj6iBj6iBO1sZ1sZBUB", false), + Lm: () => decodeRanges("uqjChBhBx+XCBpBBB", false), Lo: () => decodeRanges( - "qFQQhIFFBCBxG8Z8ZBZBFDBuBfBCJBkBBBCiDBCZZBLLBBBDRRCdBe4CBMZZBfBWVBrBYBIKBGXBCFBSoBB8B1BBETTIJBROBFHBDBBDVBCGBCEEBCBERROBBCCBPBBLJJBEBFBBDVBCGBCBBCBBCBBgBDBCUUBBBRIBCCBCVBCGBCBBCEBETTQBBYMMBGBDBBDVBCGBCBBCEBEffBCCBBBQSSCFBECBCDBEBBCCCBEEBEEBBBELBX1B1BBGBCCBCWBCPBEbbBBBDDDBffFHBCCBCWBCJBCEBEgBgBBCCBQQBSSBHBCCBCoBBDRRGCBJCBZFBGRBEXBCIBCDDBFB7BvBBCBBNFB8BBBCCCBDBCXBCCCBIBCBBKDDBDBYDBhBgCgCBGBCjBBcEB0DqBBVRRBEBFDBEEEBIIBBBFMBNyDyDBnKBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBmBPByDrTBDQBCZBGqCBHHBIRBOSBPRBPMBCCBQzBBpBkCkCBhBBC0BBIEBDhBBCGGBkCBLeByBdBDEBMrBBFZB3BWBK0BBxFuBBSHB3BdBOBBLrBBbjBBqBCBLdByDDBCFBCBBE7hB7hBBCB4-C3BBZWBKGBCGBCGBCGBCGBCGBCGBCGBoR2B2BF1CBJCCB4CBFGGBpBBC9CBSfBxBPBhQ-tGBhC0wUBC2jBBkCnBBJrIBFPBLBBjCyByBBkCBqFoDoDEGBCCBCDBCWBezBBPxBB-BFBECCBMMBaBLWBacBIuBBuBEBDIBLEBCoBBYCBCHBVPBCFBEEEBwBBCEEBDDBDBDCCZBBEKBIPPBEBDFBDFBKGBCGByEiBBej9KBNWBFwBBloItLBDpDBkCCCBIBCMBCEBCCCBCCBCCBqDBiBqLBT-BBD1BBpBLB1DEBCmEBqDJBCsBBDeBEFBDFBDFBDCBkBLBCZBCSBCBBCOBDNBjB6DBmMcBEwBBwBfBOTBCHBHlBBLdBDjBBFHBhEtCBjDnBBJzBB9CzBBN2JBKVBLHB5EFBDCCBqBBCBBEDDBVBLWBKeBiCSBCBBLVBLZBnC3BBHBBhCQQBCBCCBCcBrBcBEcBkBHBCbBc1BBLVBLSBORBvDoCB4FjBBnBDBCxJxJBoBBHBBRCB8BcBLJJBUBrBRBvBUBcWBN0BB6BBBDOOBrBBhBYBbjBBeDDJiBBENNBuBBPDBWCCkBRBCYBUBBgCGBCCCBCBCOBCJBIuBBnBHBDBBDVBCGBCBBCEBETTNEBfJBCDDClBBCaaCtBtBBzBBTDBVCBfvBBVBBC5F5FBtBBqBDBlBvBBV8B8BBpBBOoCoCBZBmBGB6FrBB0GHBDDDBGBCBBCXBQCC-CHBDmBBRCCdLLBmBBIWWMtBBUTTBnCBoGgBBgBIBCkBBSyByBBcBxDGBCBBClBBWaaBEBCBBCfBPoKoKBRBQCCBLBChBB9DwCwCB4cBnHjGBtyCgDBQvhBBSFBa68DBGmSB61GdBj3B4RBIeBSuCBSdBTvBB0BUBGSB0NnBB2MqCBGwFwFB2-FBJ1mBBqBJB43IiJBQeeBBBDPPBCBJrMBloCqDBGMBEIBIJBxzI2P2PBrBBiBiKiKBcBTrBBlPaBmHdBDwPwPBFBCDBCBBCOBCkGB8pBDBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQBlqE-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB", - false, - ), - Lt: () => decodeRanges("lOGDnB2sH2sHBGBJHBJHBNQQwBAB", false), - Lu: () => - decodeRanges( - "hCZBmDWBCGBiB2BCDOCDuBCBECEBBCCCBCCBBBDDBCBBCCBEBBCBBCECBCCDCCBCCBBBCCCBEEIJDCMCDQCDDDCCBC4BCIBBCBBDCCBCBCGCiJCCEJJHCCBBBCCCBCCBPBCIBkBDDBBBEWCGDDCBBDyBBxBgBCK2BCBMCD+CCDlBBq6ClBBCGGzW1CB0kCHHBpBBDCBhK0ECKgDCKHBJFBLHBJHBJFBMGCJHBpCDBNDBNDBNEBMDBnIFFECBDCBDEEBDBHGCBCBDDBLBBG+B+B9zCvBBxBCCBBBDGCBCBCDDJCBCgDCJCCFuqeuqeCqBCUaCoEMCE8BCLECBICFCCDCCEUCBDBCEBCOCBCBCCCBEEGGCZs5Vs5VBYBmmBnBBpEjBB9EKBCOBCGBCBBr3ByBB+EVB75CfBhsVfBhtZZBbZBbZBbCCBGDBDDBCBCHBbZBbBBCDBDHBCGBcBBCDBCEBCEEBFBcZBbZBbZBbZBbZBbZBfYBiBYBiBYBiBYBiBYBiB2pE2pEBgBB", + "guhCzBB36BDBCzLzLBBB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBmhDnBB18HxmWxmWBcBDgwhCgwhCBsTB", false, ), + Lu: () => decodeRanges("pkHi6iBi6iBBOOC0rZ0rZBUB", false), M: () => decodeRanges( - "gYvDB0IGBoIsBBCCCBCCBCCpCKBxBUBRmDmDBFBDFBDBBCDBkBffBZB8CKB7BIBKZZBCBCIBCCBCEBsBCB8BIBrBXBCgBB3BCBCRBCGBLBBeCB5BCCBFBDBBDCBKLLBbbDCB5BCCBDBFBBDCBEffBEEMCB5BCCBGBCCBCCBVBBXFBCCB5BCCBFBDBBDCBICBLBBf8B8BBDBECBCDBKpBpBBDB4BCCBFBCCBCDBIBBMBBeCB5BCCBFBCCBCDBIBBMBBQNNBCB4BBBCGBCCBCDBKLLBeeBBBnCFFBEBCCCBGBTBB+BDDBFBNHBjDDDBHBMGBqCBBcECFBByBTBCBBGKBCjBBKlDlDBSBYDBFCBCCBDGBEDBOLBCLLBCBgWCBzdDBdCBeBBfBBhCfBKuBuBBBBC2D2DBjBjB3DLBFLB8GEB6BJBCcBDxBxBBdByBEBwBQBnBIBNCBfMB5BNBxBTB5ECBCUBFHHDCBnG-BBxWgBB--CCBuEhDhDBeBrRFBqDBB1udDBCJBhBBBxCBBxIEEFYYBDBF0C0CBzBzBBQBbRBOnBnBBGBaMBtBDBwBNBlBkCkCBMBNJJBuBuBBBBzBCCBBBDBBGBBCqBqBBDBGBBtHHBCBBx5TiXiXBOBRPBuejHjH2EEBn0BCBCBBGDBpBCBFmFmFB+R+RBCBiCEB+JBBwCDBnCKByBDB7DCB2BOBqBDDBLLBCBuBKBI+B+BBBBlBNBRBBtBNNBBBxBNBJDBCBB9CLBHDD+ELBWDB4BBBCGBDBBDCBKLLBDDBFBEEBkCIBCDDCDBCEBCPPBzCzCBQBYyCyCBSBsHGBDIBcBBzCQBrDMBmDOBhIOB2HFBCBBDDBCCCBuEuEBFBDGBEddBIBpBGBCDBJKKBJBvBPB2MHBCHBzCVBCNB7DFBECCBCCBFBCjCjCBDBCBBCEB8KDBKBBCxBxBBFBEEBYmnFmnFHOBpmLRBhuCEB8BGB5gBCCB1BBIDByCMMBslTslTBizEizEBsBBDWB-QEBEFBJHBDGBfDB1ECB89B2BBFxBBJPPXEBCOBxqBGBCQBDGBCBBCEBlDhFhFBFB4L+B+BBCB9PDB-HBBhXGBuDGB29lYvHB", - false, - ), - Mc: () => - decodeRanges( - "joC4B4BDCBJDBCBBzBBB7BCBHBBDBBLsBsB7BCBjC7B7BBBBJCCB2B2BB7B7BCHHBDDBLLnDBBCBBECBCCBLqBqBBBB+BDB+BBB7BCCBDBDBBCBBKBBdPPB7B7BBBBGCBCCBLrBrBBsCsCBBBHHBTBBrKBBgCsFsFBFFHDDBaaBLLBBBDGBWBBDFBDLLBBB5zBffiEIIBGBCBB7KDBDCBFBBCFBhHBB7BCCKCCBJJBEByExBxBGCCBDBCBB+BffFBBD9B9BDCBCEEBxBxBBGBJBBsFWW35EBB0-dBBD5C5CBzBzBBOBvEBBwBxBxBBFFBDDBBBvDBBDBBZuBuBCuDuDDBBGuHuHBCCBCCBCC0gZCCgEuBuBBBBFBB0DZZB8B8BxBCBKBBO+C+CBBBEBBCrFrFBBBgBBB7BBBCDBDBBDCBKLLB1C1CBBBIDDCDBCBBCmDmDBBBJBBErDrDBBBHCCBCBDuHuHBBBHDBDyDyDBBBJBBCuDuDCBBHoDoDCBBFmImIBBBK4H4HBEBCBBFDDCvEvEBBBJDBF1C1CeBB-B4M4MPrDrDIDD2GEBFBBC-K-KBNNxBBBJBBCpvQpvQBBBlxD2BBpDBB0rYBBHFB", + "3kCymhCymhCBDBvM8lB8lBBHBCDDCDBCEBCPPB47C47CkuQRB-lhBBB", false, ), - Me: () => decodeRanges("okBBB1xF-wB-wBBCBCCBsshBCB", false), + Mc: () => decodeRanges("49kCCBIDDCDBCBBCvavaswSCB", false), Mn: () => - decodeRanges( - "gYvDB0IEBqIsBBCCCBCCBCCpCKBxBUBRmDmDBFBDFBDBBCDBkBffBZB8CKB7BIBKZZBCBCIBCCBCEBsBCB8BIBrBXBCfB4BCCFHBFEEBFBLBBe7B7BFDBJVVBbbDBB6BFFBFFBDDBBBEffBEEMBB6BFFBDBCBBFVVBXXBEBC7B7BDCCBCBJIIBMMBff+BNNzBEE4BCCBBBGCBCDBIBBMBBe7B7BDHHGBBVBBdBB6BBBFDBJVVBeepCIIBBBC7C7CDGBNHBjDDDBHBMGBqCBBcEC4BNBCEBCBBGKBCjBBKnDnDBCBCFBCBBDBBaBBFCBRDBODDBHHQgWgWBBBzdCBeBBfBBfBBhCBBCGBJDDBJBKuBuBBBBC2D2DBjBjB3DCBFBBKHHBBB8GBBD7B7BCGBCCCDHBHJBDxBxBBMBCPByBDBxBCCBDBCGGpBIBNBBhBDBDBBCCB5BCCBEECCB7BHBDBB5ECBCMBCGBFHHEBBnG-BBxWMBFEEBKB--CCBuEhDhDBeBrRDBsDBB1udFFBIBhBBBxCBBxIEEFaaBGG4EBBbRBOnBnBBGBaKBvBCBxBDDBCBDBBoBkCkCBEBDBBDBBNJJwB0B0BCCBDBBGBBCrBrBBJJvHDDFx5Tx5TiXPBRPBuejHjH2EEBn0BCBCBBGDBpBCBFmFmFB+R+RBCBiCEB+JBBwCDBnCKByBDB8D3B3BBNBqBDDBLLBBByBDBDBBI+B+BBBBlBEBCHB-BNNB1B1BBHBLDBDgDgDBBBDCCBHHD+E+EEHBWBB6BBBEmBmBBFBEEBnCFBOECPBB2CHBDCBCYY1CFBCFFBCCBvHvHBCBHBBCBBcBB2CHBDCCBrDrDCDDBEBCmDmDCDDBCBCEBkIIBCBBhIBBCFFxEDBDBBFhBhBBIBpBFBDDBJKKBEBDCBvBMBCBB3MGBCFBCzCzCBUBDGBCBBCBB7DFBECCBCCBFBCpCpCBEEC8K8KBMMB1B1BBDBGCCYmnFmnFHOBpmLLBECBhuCEB8BGB5gBgCgCBCByC5lT5lTBizEizEBsBBDWBhRCBSHBDGBfDB1ECB89B2BBFxBBJPPXEBCOBxqBGBCQBDGBCBBCEBlDhFhFBFB4L+B+BBCB9PDB-HBBhXGBuDGB29lYvHB", - false, - ), - N: () => - decodeRanges( - "wBJB5DBBGDDBBBitBJBnEJBnGJB9MJB3DJBFFBtDJB3DJB3DJBDFBvDMB0DJBJGBoDJBpDGBISBuDJBhDJB3DJBnCTBtIJBnCJBwWTBybCBwHJBHJBXJBtJJBhEKBmFJBHJB3FJB3CJBnEJBHJB3gBEEBEBHJBnGyBBDEB3W7BBvCVB3TdBqrBqYqYaIBPCB4KDBrEJBfHBCOBhBJBoBOBh7cJB9FJBhKFB7EJBnBJBnGJBXJB3CJB3MJB34UJBuPsBBN4BBSBB2KaBlBDBeJJnEEBrGJBvdHBaGBoBIBsCEBXFBhFBBDPBDtBBhCIB1BBBfCBsCEBpDHBZHBqBGBrKFBxBJBHJB3IeB-EJBrBDBxDGBnEdBhEJB9BJBxEJBITB8HJB3KJB3DJB3LJBnDJBHTBtCLBlNSB+CJB3UJB3CcBkHJBnCJBnNJBnDUBshBuDBimPJBnpCJB3CJBnEJBCGBvQJBnIWB6yXJBnuBTBNTBtDYB2iBxBBhqCJBnNJB3PJB4HJBtWIBhEJB4Y6BBCCBCDBtCsBBCOBjeMBk3CJB", - false, - ), - Nd: () => - decodeRanges( - "wBJnxBJnEJnGJ9MJ3DJ3DJ3DJ3DJ3DJ3DJ3DJ3DJ3DJhDJ3DJnCJ3IJnCJn6BJnBJtJJhEJnFJHJ3FJ3CJnEJHJnuiBJnVJnBJnGJXJ3CJ3MJ34UJnsBJnkCJHJ9YJhEJ9BJxEJ3IJ3KJ3DJ3LJnDJHTtCJnNJnDJ3UJ3CJ3HJnCJnNJ3uQJnpCJ3CJnEJ3QJ37XJ12CxBhqCJnNJ3PJ4HJ2aJ30EJ", - true, - ), - Nl: () => - decodeRanges("u3FCBwzCiBBDDB-zDaaBHBPCBs1dJBxyW0BBtOJJnEEBrhIuDB", false), - No: () => - decodeRanges( - "yFBBGDDBBB2pCFB5LFB5DCBmEGB6GGBSIByNJB2hBTB0jBJBhP20B20BEFBHJBnGPBqB3W3WB6BBvCVB3TdBqrB1kB1kBBCBrEJBfHBCOBhBJBoBOBxrdFBymWsBBiCDBSBB2KaBlBDB1pBHBaGBoBIBsCEBXFBhFBBDPBDtBBhCIB1BBBfCBsCEBpDHBZHBqBGBrKFBhLeB-EJBrBDBxDGBnETB8LTBmqBBBvNIBobSB0aUBn8SGB-YWBqhZTBNTBtDYBvqFIBid6BBCCBCDBtCsBBCOBjeMB", - false, - ), - P: () => - decodeRanges( - "hBCBCFBCDBLBBEBBbCBCccCkBkBGEELBBEEE-VJJzOFBqBBB0BCCDDDtBBBVBBCBBOCCBBBrCDBnDsBsBBMBqHCB3BOBgBmImIBLLtE5D5D6DnMnMNwLwL7CLLBpFpFBNBCmBmBBCBoCrCrCBDBFBBwDFBsFlTlTBHB4EuTuTtBBBvCCBoCBB+ECBCCBmBKB6JBB5GBBhEGBCFBhFBBLGBdCB9DDB8BEB-BBBhCHBM9Z9ZBWBJTBCMBCLBfBBPBB6TDBeBB+hBNBwCBBgBJB0MVBgCDBhBBB8XDBCBBxDwEwEBtBBCfBDLBkNCBFJBDLBRNNjD7C7CjgdBBuICBkDLL0DFB9LDB3CBBpBCBCyByBBwBwBiDMBRBB9DDB-DBBRBB6HzqUzqUBxGxGBIBXiBBCNBCFFCBB2ECBCFBCDBLBBEBBbCBCccCCCBFB7MCB9UxBxB-MoXoXoGgBgBxIIBnBxDxDBFBjCGB6CDByO-J-JoFEBtBDB+FGBuDBBCDB-DDBxBBBwCDBFOOCCB5CFBsDrJrJBCCBzDzDBDBLBBCpDpD7HWBqDCBdMBtCjEjEBBB9HpIpIBBB8E9C9CBGB0CCBCEB+CJB4GgDgDBDBrBBBmUBBrCMBwFxjBxjBBDB97CBB8zOBBmEiCiCBDBJpRpRBBBoJDBoK9lT9lTovHEB07C-a-aBAB", - false, - ), - Pc: () => decodeRanges("-Cg-Hg-HBUU-u3BBBZCBwHAB", false), - Pd: () => - decodeRanges( - "tB9qB9qB0BiyDiyDmgBqgCqgCBEBiwDDDgBBBFdd-NUUwDxszBxszBBmBmBLqFqFhzD-J-J", - false, - ), - Pe: () => - decodeRanges( - "pB0B0BgB+1D+1DC-6B-6BqtC4B4BQ7T7TCff-hBMCxChBhBCGC1MUChCCCiBmhBmhBCECtBGCtNICEGCDBB-ozB6G6GeOCESSCCCrF0B0BgBGD", - false, - ), - Pf: () => decodeRanges("7F+6H+6HEddpuDCCFDDQEE", false), - Pi: () => decodeRanges("rFt7Ht7HDBBDaapuDCCFDDQEE", false), - Po: () => - decodeRanges( - "hBCBCCBDECBLLBEEBcclCGGPBBI-V-VJzOzOBEBqB3B3BDDDtBBBVBBCBBOCCBBBrCDBnDsBsBBMBqHCB3BOBgBmImIBLLtE5D5D6DnMnMNwLwL7CLLBpFpFBNBCxDxDrCEBFBBwDFBsFlTlTBHBmY9D9DBBBoCBB+ECBCCBmBFBCDB6JBB5GBBhEGBCFBhFBBLGBdCB9DDB8BEB-BBBhCHBMjajaBJJBGBJIBDDBDCBEKBCCCBIB7kDDBCBBxDwEwEBFFBBBDDDBHBCBBCDDBLLBDBCJBDDBCCCBLBDCBtNCB6B+F+FjgdBBuICBkDLL0DFB9LDB3CBBpBCBCyByBBwBwBiDMBRBB9DDB-DBBRBB6HlxUlxUBFBDXXVBBDDBECBCDBICBHCCB2E2EBBBCCBDECBLLBEEBcclBDDB7M7MBBB9UxBxB-MoXoXoGgBgBxIIBnBxDxDBFBjCGB6CDB5dEBtBDB+FGBuDBBCDB-DDBxBBBwCDBFOOCCB5CFBsDrJrJBCCBzDzDBDBLBBCpDpD7HWBqDCBdMBtCjEjEBBB9HpIpIBBB8E9C9CBGB0CCBCEB+CJB4GgDgDBDBrBBBmUBBrCMBwFxjBxjBBDB97CBB8zOBBmEiCiCBDBJpRpRBBBoJDBoK9lT9lTovHEB07C-a-aBAB", - false, - ), - Ps: () => - decodeRanges( - "oBzBzBgB-1D-1DC-6B-6B-rCEEnB4B4BQ7T7TCff-hBMCxChBhBCGC1MUChCCCiBmhBmhBCECaTTCECtNICEGCDipzBipzB4GeeCMCESSCCCrFzBzBgBEEDAB", - false, - ), + decodeRanges("3kCymhCymhCBDBvM-lB-lBBEBOECPBB47CkuQkuQBKBECB-lhBBB", false), + N: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true), + Nd: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true), + P: () => decodeRanges("u6GBBwBvv8Bvv8BmzBBBCBBpgCssUssUBBBwkeAB", false), + Pd: () => decodeRanges("urjCA", true), + Po: () => decodeRanges("u6GBBwB1i+B1i+BBCCBpgCpgCssUCBwkeAB", false), S: () => decodeRanges( - "kBHHRCBgBCCcCCkBEBCBBDCCBCBDEEfgBgBrODBNNBGGBCCCBPB2DPPBxDxDsErIrIBBB3DCBDDDBvGvGLUUB4H4HIBBpEqLqLBHHB2H2H-DjEjEBGBlEwGwGqBmGmGiGCBQCCBBBDFBVECmEHBCFBCBBGDBmGBBxXJB0WuLuLlL+E+EBgBBiLJBKIBhiBCCBBBMCBOCBOCBOBBmCOOoBCBOCBUgBBgCBBCDBCBBLCCBBBGFBCECFMMBFFBDBGDBC7B7BBFFB2LBFcBD+HBXKByCtCBXnTBtBwBBDeBLyMBX+BBFfBD1LBDfBCoDBmHFBmLBBvBZBC4CBN1GBbPBFOOBNNWBBHBB8CBB0HBBFJBhBlBBKRRBdBMdBJQQBeBLmBBQ-JBhuG-BBx0V2BB6RWBKBBoDBB+EDBLDB+RCBiHPPB+9T+9TpEQB+LPBgEtBtBBCBjDCCBBBD7E7EHRRBBBgBCCcCCiEGBCGBOBB6JIB6BQBDCBCMBEwBwBBrBB7zBBBwSmWmWBwtCwtC2kCcBr6SDBG3qU3qUk7DvHBRzNB9EzDB9B1HBLmBBD7BBGCBXBBIdBF8BBWhCBE7F7FB1CBrbaagBaagBaagBaagBaa9B-PB4BDBzBHBCNBCBBp2BwNwNttCEE+DiOiOBvIvIBqBBFjDBNOBDOBCOBCkBBYgFB5BcBOrBBFIBIBBPFB7E3eBFQBEMBE2DBF+CBHLBFQQBKBF3BBJJBHnBBJdBDLBFBB-BzKBNNBDMBEJBG3BBIOBDKBHIBIyEBC7CB", - false, - ), - Sc: () => - decodeRanges( - "kB+D+DBCBqnB8D8DzPBBzPBBI2H2HoImSmS8sClmClmCBfB47hBkuVkuVtD7E7E8GBBEBB3-HDB-4wBxtCxtC", - false, - ), - Sk: () => - decodeRanges( - "+CCCoCHHFEEqQDBNNBGGBCCCBPB2DPPBjoBjoB15FCCBBBMCBOCBOCBOBB9kEBBkzdWBKBBoDBBxePPBniUniUBPB8bCCjF4g9B4g9BBDB", - false, - ), - Sm: () => - decodeRanges( - "rBRRBBB+BCCuBFFmBgBgB-XwQwQBBB8xGOOoBCBOCBsEoBoBBDBHlClCBDBGBBFGDIgBgBBDDCgBgBBqIBhBBB7CffBXBpBFB2OKK3BHBwDxKxKBDBDeBLPBhIiEBX+BBFfBDhIBxBUBDFB9+zB5Z5ZCCBlFRRBBB+BCCkEHHBCBitDBBypyBaagBaagBaagBaagBaat5FBB", + "nhJCBz+CDBlPBBK-82B-82BBxzvBxzvBBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", false, ), + Sm: () => decodeRanges("usjCB", true), So: () => decodeRanges( - "mFDDFCCyerIrIBgEgEBvGvGLUUB4H4HkQ2L2LjEFBClElEwGqBqBoMCBQCCBBBDFBVECmEHBCFBCBBGDBmGBBxXJB0WzWzW+EhBBiLJBKIBksBBBCDBCBBLCCBHHBEBCECFMMBPPCBBC7B7BBKKBDBDDBCBBCBBCGBCeBDBBCCCBdBtIHBFTBDGBDwCBCdBanBBHnCBXKByCtCBX2FBCIBC1BBJuDBC3HBtBrBBhC-HBhQvBBWBBHmBBDfBCoDBmHFBmLBBvBZBC4CBN1GBbPBFOOBNNWBBHBBxKBBFJBhBlBBKRRBdBMdBJQQBeBLmBBQ-JBhuG-BBx0V2BBibDBLBBC+R+RBBBn2UPBgEuBuBBBBlPEEFBBOBB6JIB6BQBDCBCMBEwBwBBrBB7zBBBwS3jD3jD2kCHBFQBr6SDBG3qU3qUk7DvHBRzNB9EzDB9B1HBLmBBD7BBGCBXBBIdBF8BBWhCBE7F7FB1CBqlB-PB4BDBzBHBCNBCBBp2B96C96CiEyWyWBqBBFjDBNOBDOBCOBCkBBYgFB5BcBOrBBFIBIBBPFB7E6HBG3WBFQBEMBE2DBF+CBHLBFQQBKBF3BBJJBHnBBJdBDLBFBB-BzKBNNBDMBEJBG3BBIOBDKBHIBIyEBC7CB", + "nhJCBz+CDBlPBBKxwmDxwmDBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", false, ), - Z: () => decodeRanges("gBgEgEgvFgsCgsCBJBeBBGwBwBh9DAB", false), - Zl: () => decodeRanges("ohIA", true), - Zp: () => decodeRanges("phIA", true), - Zs: () => decodeRanges("gBgEgEgvFgsCgsCBJBlBwBwBh9DAB", false), }); // Additions from Unicode 15.0 → 16.0 per stable script name. -const _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({}); +const _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ + Arabic: () => decodeRanges("3kCrxhCrxhCBBB4BAB", false), + Balinese: () => decodeRanges("u6GBwBA", true), + Common: () => + decodeRanges( + "nhJCBz+CDBlPBBKxwmDxwmDB4HBHzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", + false, + ), + Cyrillic: () => decodeRanges("pkHB", true), + Egyptian_Hieroglyphs: () => decodeRanges("gjtC68D", true), + Han: () => decodeRanges("w-6FtT", true), + Kawi: () => decodeRanges("66nCA", true), + Khitan_Small_Script: () => decodeRanges("-njDA", true), + Latin: () => decodeRanges("r+pBCNC", true), + Myanmar: () => decodeRanges("w2lCT", true), +}); // Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw // SyntaxError on these names, so platform sweep is impossible. const _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({ - Adlam: () => new UnicodeRangeTable(decodeRanges("go6DrCFJFB", true)), - Ahom: () => new UnicodeRangeTable(decodeRanges("g4lCaDOFW", true)), - Anatolian_Hieroglyphs: () => - new UnicodeRangeTable(decodeRanges("ggxCmS", true)), - Arabic: () => - new UnicodeRangeTable( - decodeRanges( - "gwBEBCFBCNBCCBCfBCJBMZBCrDBChBBxCvBBxHeBCBBGqCBCcBxy8ByDBRqLBDvCBD1BBIhBhBBOBxDEBCmEBk7DeBkCCB4BDBh43BDBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQB1BBB", - false, - ), - ), - Armenian: () => new UnicodeRangeTable(decodeRanges("xpBlBDxBDCks9BE", true)), - Avestan: () => new UnicodeRangeTable(decodeRanges("g4iC1BEG", true)), - Balinese: () => new UnicodeRangeTable(decodeRanges("g4GsCCxB", true)), - Bamum: () => new UnicodeRangeTable(decodeRanges("g1pB3CpowB4R", true)), - Bassa_Vah: () => new UnicodeRangeTable(decodeRanges("w26CdDF", true)), - Batak: () => new UnicodeRangeTable(decodeRanges("g+GzBJD", true)), - Bengali: () => - new UnicodeRangeTable( - decodeRanges("gsCDBCHBDBBDVBCGBCEEBCBDIBDBBDDBJFFBCCBDBDYB", false), - ), - Bhaiksuki: () => new UnicodeRangeTable(decodeRanges("ggnCICsBCNLc", true)), - Bopomofo: () => new UnicodeRangeTable(decodeRanges("qXB6wLqBxDf", true)), - Brahmi: () => new UnicodeRangeTable(decodeRanges("ggkCtCFjBKA", true)), - Braille: () => new UnicodeRangeTable(decodeRanges("ggK-H", true)), - Buginese: () => new UnicodeRangeTable(decodeRanges("gwGbDB", true)), - Buhid: () => new UnicodeRangeTable(decodeRanges("g6FT", true)), - Canadian_Aboriginal: () => - new UnicodeRangeTable(decodeRanges("ggF-TxRlC7tgCP", true)), - Carian: () => new UnicodeRangeTable(decodeRanges("g1gCwB", true)), - Caucasian_Albanian: () => - new UnicodeRangeTable(decodeRanges("wphCzBMA", true)), - Chakma: () => new UnicodeRangeTable(decodeRanges("gokC0BCR", true)), - Cham: () => new UnicodeRangeTable(decodeRanges("gwqB2BKNDJDD", true)), - Cherokee: () => new UnicodeRangeTable(decodeRanges("g9E1CDFz7lBvC", true)), - Chorasmian: () => new UnicodeRangeTable(decodeRanges("w9jCb", true)), - Common: () => - new UnicodeRangeTable( - decodeRanges( - "AgCBbFBbuBBCOBCEBYgBgBiOmBBGEBDTB1DKKHCC+THHPEEhB9E9ElQiEiEB6mB6mB2MDBjJwvBwvBBBBoCBBsGBBCumBumBOIIBCBCFBCCBDmYmYBKBD2CBCKBEKBCOBSgBBgClBBCCBDFBCaBCQBqBCBF5UBXKBW-cBhIzTBDfBCoDBhQ9CBzMUBCCCBXBQHBFDB8CBBE7C7CB0E0EBOBhBlBBKxBxBB+BBgBwCBwB5C5CBmFBhuG-BBhoWhBBnDCBmFJB1HhFhFsMPPBzuUzuUBxGxGBIBXiBBCSBCDB0ECCBeBbFBbKBLuBuBBhChCBFBCGBLEBjICBFsBBEIBxCMB0BsBBlHaBltuBDB96D5HBHzNB9EzDB9B1HBLmBBD9BBEQBJBBIdBF8BB2GTBNTBN2CBKYBoE0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDjJBDxBByjFjCBtC8BBjWrBBFjDBNOBDOBCOBCkBBLtFB5BZBCBBOrBBFIBIBBPFB7E3eBFQBEMBE2DBF+CBHLBFQQBKBF3BBJJBHnBBJdBDLBFBB-BzKBNNBDMBEJBG3BBIOBDKBHIBIyEBClDBoghYffB+CB", - false, - ), - ), - Coptic: () => new UnicodeRangeTable(decodeRanges("ifNxkKzDGG", true)), - Cuneiform: () => new UnicodeRangeTable(decodeRanges("ggoC5cnDuDCEMjG", true)), - Cypriot: () => - new UnicodeRangeTable(decodeRanges("ggiCFBDCCBqBBCBBEDD", false)), - Cypro_Minoan: () => new UnicodeRangeTable(decodeRanges("w8rCiD", true)), - Cyrillic: () => - new UnicodeRangeTable( - decodeRanges("ggBkEBDoFBx6FKBhFtCtCojEfBhie-CBv8VBBhw4B9BBiBAB", false), - ), - Deseret: () => new UnicodeRangeTable(decodeRanges("gghCvC", true)), - Devanagari: () => - new UnicodeRangeTable(decodeRanges("goCwCFODZh7nBfhwcJ", true)), - Dives_Akuru: () => - new UnicodeRangeTable(decodeRanges("gomCGBDDDBGBCBBCdBCBBDLBKJB", false)), - Dogra: () => new UnicodeRangeTable(decodeRanges("ggmC7B", true)), - Duployan: () => new UnicodeRangeTable(decodeRanges("ggvDqDGMEIIJDD", true)), - Egyptian_Hieroglyphs: () => - new UnicodeRangeTable(decodeRanges("ggsC1iBL68D", true)), - Elbasan: () => new UnicodeRangeTable(decodeRanges("gohCnB", true)), - Elymaic: () => new UnicodeRangeTable(decodeRanges("g-jCW", true)), - Ethiopic: () => - new UnicodeRangeTable( - decodeRanges( - "gwEoCBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBDfBEZBnvGWBKGBCGBCGBCGBCGBCGBCGBCGBjpfFBDFBDFBKGBCGBylvCGBCDBCBBCOB", - false, - ), - ), Garay: () => new UnicodeRangeTable(decodeRanges("gqjClBEcJB", true)), - Georgian: () => - new UnicodeRangeTable( - decodeRanges("glElBBCGGDqBBCDBx8CqBBDCBhiElBBCGG", false), - ), - Glagolitic: () => - new UnicodeRangeTable(decodeRanges("ggL-Ch9sDGCQDGCBCE", true)), - Gothic: () => new UnicodeRangeTable(decodeRanges("w5gCa", true)), - Grantha: () => - new UnicodeRangeTable( - decodeRanges("g4kCDBCHBDBBDVBCGBCBBCEBDIBDBBDCBDHHGGBDGBEEB", false), - ), - Greek: () => - new UnicodeRangeTable( - decodeRanges( - "wbDBCCBDDBCFFCCCBBBCCCBSBC+BBPPBnpGEBzBEBFEB1ChKhKBUBDFBDlBBDFBDHBCGCBdBD0BBCOBCNBDFBCSBDCBCIBoJ-xiB-xiB7uVuCBSgj0Bgj0BBkCB", - false, - ), - ), - Gujarati: () => - new UnicodeRangeTable( - decodeRanges("h0CCBCIBCCBCVBCGBCBBCEBDJBCCBCCBDQQBCBDLBIGB", false), - ), - Gunjala_Gondi: () => - new UnicodeRangeTable(decodeRanges("grnCFCBCkBCBCFIJ", true)), - Gurmukhi: () => - new UnicodeRangeTable( - decodeRanges("hwCCBCFBFBBDVBCGBCBBCBBCBBDCCBDBFBBDCBEIIBCBCIIBPB", false), - ), Gurung_Khema: () => new UnicodeRangeTable(decodeRanges("go4C5B", true)), - Han: () => - new UnicodeRangeTable( - decodeRanges( - "g0LZBC4CBN1GBwBCCaIBPDBle-tGBhC-vUBhoWtLBDpDBpodBBNBBvgkB-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB", - false, - ), - ), - Hangul: () => - new UnicodeRangeTable( - decodeRanges("goE-HvxHBiI9CyDeiCei3dckUj9KNWFwBl9JeEFDFDFDC", true), - ), - Hanifi_Rohingya: () => new UnicodeRangeTable(decodeRanges("gojCnBJJ", true)), - Hanunoo: () => new UnicodeRangeTable(decodeRanges("g5FU", true)), - Hatran: () => new UnicodeRangeTable(decodeRanges("gniCSCBGE", true)), - Hebrew: () => - new UnicodeRangeTable( - decodeRanges("xsB2BBJaBFFBpp9BZBCEBCCCBCCBCCBIB", false), - ), - Hiragana: () => - new UnicodeRangeTable(decodeRanges("hiM1CBHCBi7-C+IBTeeBBBulQAB", false)), - Imperial_Aramaic: () => new UnicodeRangeTable(decodeRanges("giiCVCI", true)), - Inherited: () => - new UnicodeRangeTable( - decodeRanges( - "gYvDB2IBBlOKBbhXhXBCB8qEeBiQCBCMBCGBFHHEBBnG-BBtQBBjGgBB65DDBsDBBmrzBPBRNBwejHjH7iEl+uBl+uBBsBBDWBhRCBSHBDGBfDBz6rYvHB", - false, - ), - ), - Inscriptional_Pahlavi: () => - new UnicodeRangeTable(decodeRanges("g7iCSGH", true)), - Inscriptional_Parthian: () => - new UnicodeRangeTable(decodeRanges("g6iCVDH", true)), - Javanese: () => new UnicodeRangeTable(decodeRanges("gsqBtCDJFB", true)), - Kaithi: () => new UnicodeRangeTable(decodeRanges("gkkCiCLA", true)), - Kannada: () => - new UnicodeRangeTable(decodeRanges("gkDMCCCWCJCEDICCCDIBHBCDDJCC", true)), - Katakana: () => - new UnicodeRangeTable( - decodeRanges( - "hlM5CBDCBxHPBxGuBBC3CBvgzBJBCsBBzisBDBCGBCBBCgJgJBBBzBPPBCB", - false, - ), - ), - Kawi: () => new UnicodeRangeTable(decodeRanges("g4nCQCoBEc", true)), - Kayah_Li: () => new UnicodeRangeTable(decodeRanges("goqBtBCA", true)), - Kharoshthi: () => - new UnicodeRangeTable(decodeRanges("gwiCDCBGHCCCcDCFJII", true)), - Khitan_Small_Script: () => - new UnicodeRangeTable(decodeRanges("k-7C84G84GB0OBqBAB", false)), - Khmer: () => new UnicodeRangeTable(decodeRanges("g8F9CDJHJnPf", true)), - Khojki: () => new UnicodeRangeTable(decodeRanges("gwkCRCuB", true)), - Khudawadi: () => new UnicodeRangeTable(decodeRanges("w1kC6BGJ", true)), Kirat_Rai: () => new UnicodeRangeTable(decodeRanges("gq7C5B", true)), - Lao: () => - new UnicodeRangeTable( - decodeRanges("h0DBBCCCBDBCXBCCCBVBDEBCCCBFBCJBDDB", false), - ), - Latin: () => - new UnicodeRangeTable( - decodeRanges( - "hCZBHZBwBQQGWBCeBCgOBoBEB8wGlBBHwBBGDBGMBClCBiC-HByLOORMBuEBBHccSoBB42CfBj1elDBEiCBDBBCCCBGBWNBxZqBBCIBCDB38TGB7gBZBHZBmhCFBCpBBCIBm61BeBHFB", - false, - ), - ), - Lepcha: () => new UnicodeRangeTable(decodeRanges("ggH3BEOEC", true)), - Limbu: () => new UnicodeRangeTable(decodeRanges("goGeBCLBFLBFEEBKB", false)), - Linear_A: () => new UnicodeRangeTable(decodeRanges("gwhC2JKVLH", true)), - Linear_B: () => - new UnicodeRangeTable(decodeRanges("gggCLCZCSCBCODNjB6D", true)), - Lisu: () => new UnicodeRangeTable(decodeRanges("wmpBvBx1eA", true)), - Lycian: () => new UnicodeRangeTable(decodeRanges("g0gCc", true)), - Lydian: () => new UnicodeRangeTable(decodeRanges("gpiCZGA", true)), - Mahajani: () => new UnicodeRangeTable(decodeRanges("wqkCmB", true)), - Makasar: () => new UnicodeRangeTable(decodeRanges("g3nCY", true)), - Malayalam: () => - new UnicodeRangeTable(decodeRanges("goDMCCCyBCCCFFPDZ", true)), - Mandaic: () => new UnicodeRangeTable(decodeRanges("giCbDA", true)), - Manichaean: () => new UnicodeRangeTable(decodeRanges("g2iCmBFL", true)), - Marchen: () => new UnicodeRangeTable(decodeRanges("wjnCfDVCN", true)), - Masaram_Gondi: () => - new UnicodeRangeTable(decodeRanges("gonCGBCBBCrBBECCBCCBHBJJB", false)), - Medefaidrin: () => new UnicodeRangeTable(decodeRanges("gy7C6C", true)), - Meetei_Mayek: () => new UnicodeRangeTable(decodeRanges("g3qBWqGtBDJ", true)), - Mende_Kikakui: () => new UnicodeRangeTable(decodeRanges("gg6DkGDP", true)), - Meroitic_Cursive: () => - new UnicodeRangeTable(decodeRanges("gtiCXFTDtB", true)), - Meroitic_Hieroglyphs: () => - new UnicodeRangeTable(decodeRanges("gsiCf", true)), - Miao: () => new UnicodeRangeTable(decodeRanges("g47CqCF4BIQ", true)), - Modi: () => new UnicodeRangeTable(decodeRanges("gwlCkCMJ", true)), - Mongolian: () => - new UnicodeRangeTable(decodeRanges("ggGBBDCCBSBH4CBIqBB2t-BMB", false)), - Mro: () => new UnicodeRangeTable(decodeRanges("gy6CeCJFB", true)), - Multani: () => - new UnicodeRangeTable(decodeRanges("g0kCGBCCCBCBCOBCKB", false)), - Myanmar: () => new UnicodeRangeTable(decodeRanges("ggE-EhqmBeiDfxibT", true)), - Nabataean: () => new UnicodeRangeTable(decodeRanges("gkiCeJI", true)), - Nag_Mundari: () => new UnicodeRangeTable(decodeRanges("wm5DpB", true)), - Nandinagari: () => new UnicodeRangeTable(decodeRanges("gtmCHDtBDK", true)), - New_Tai_Lue: () => new UnicodeRangeTable(decodeRanges("gsGrBFZHKEB", true)), - Newa: () => new UnicodeRangeTable(decodeRanges("gglC7CCE", true)), - Nko: () => new UnicodeRangeTable(decodeRanges("g+B6BDC", true)), - Nushu: () => new UnicodeRangeTable(decodeRanges("h-7CvsQvsQBqMB", false)), - Nyiakeng_Puachue_Hmong: () => - new UnicodeRangeTable(decodeRanges("go4DsBENDJFB", true)), - Ogham: () => new UnicodeRangeTable(decodeRanges("g0Fc", true)), - Ol_Chiki: () => new UnicodeRangeTable(decodeRanges("wiHvB", true)), Ol_Onal: () => new UnicodeRangeTable(decodeRanges("wu5DqBFA", true)), - Old_Hungarian: () => new UnicodeRangeTable(decodeRanges("gkjCyBOyBIF", true)), - Old_Italic: () => new UnicodeRangeTable(decodeRanges("g4gCjBKC", true)), - Old_North_Arabian: () => new UnicodeRangeTable(decodeRanges("g0iCf", true)), - Old_Permic: () => new UnicodeRangeTable(decodeRanges("w6gCqB", true)), - Old_Persian: () => new UnicodeRangeTable(decodeRanges("g9gCjBFN", true)), - Old_Sogdian: () => new UnicodeRangeTable(decodeRanges("g4jCnB", true)), - Old_South_Arabian: () => new UnicodeRangeTable(decodeRanges("gziCf", true)), - Old_Turkic: () => new UnicodeRangeTable(decodeRanges("ggjCoC", true)), - Old_Uyghur: () => new UnicodeRangeTable(decodeRanges("w7jCZ", true)), - Oriya: () => - new UnicodeRangeTable(decodeRanges("h4CCCHDBDVCGCBCEDIDBDCICFBCEDR", true)), - Osage: () => new UnicodeRangeTable(decodeRanges("wlhCjBFjB", true)), - Osmanya: () => new UnicodeRangeTable(decodeRanges("gkhCdDJ", true)), - Pahawh_Hmong: () => - new UnicodeRangeTable(decodeRanges("g46ClCLJCGCUGS", true)), - Palmyrene: () => new UnicodeRangeTable(decodeRanges("gjiCf", true)), - Pau_Cin_Hau: () => new UnicodeRangeTable(decodeRanges("g2mC4B", true)), - Phags_Pa: () => new UnicodeRangeTable(decodeRanges("giqB3B", true)), - Phoenician: () => new UnicodeRangeTable(decodeRanges("goiCbEA", true)), - Psalter_Pahlavi: () => new UnicodeRangeTable(decodeRanges("g8iCRIDNG", true)), - Rejang: () => new UnicodeRangeTable(decodeRanges("wpqBjBMA", true)), - Runic: () => new UnicodeRangeTable(decodeRanges("g1FqCEK", true)), - Samaritan: () => new UnicodeRangeTable(decodeRanges("ggCtBDO", true)), - Saurashtra: () => new UnicodeRangeTable(decodeRanges("gkqBlCJL", true)), - Sharada: () => new UnicodeRangeTable(decodeRanges("gskC-C", true)), - Shavian: () => new UnicodeRangeTable(decodeRanges("wihCvB", true)), - Siddham: () => new UnicodeRangeTable(decodeRanges("gslC1BDlB", true)), - SignWriting: () => new UnicodeRangeTable(decodeRanges("gg2DrUQECO", true)), - Sinhala: () => - new UnicodeRangeTable( - decodeRanges("hsDCBCRBEXBCIBCDDBFBEFFBEBCCCBGBHJBDCBt-gCTB", false), - ), - Sogdian: () => new UnicodeRangeTable(decodeRanges("w5jCpB", true)), - Sora_Sompeng: () => new UnicodeRangeTable(decodeRanges("wmkCYIJ", true)), - Soyombo: () => new UnicodeRangeTable(decodeRanges("wymCyC", true)), - Sundanese: () => new UnicodeRangeTable(decodeRanges("g8G-BhIH", true)), Sunuwar: () => new UnicodeRangeTable(decodeRanges("g+mChBPJ", true)), - Syloti_Nagri: () => new UnicodeRangeTable(decodeRanges("ggqBsB", true)), - Syriac: () => new UnicodeRangeTable(decodeRanges("g4BNC7BDCxIK", true)), - Tagalog: () => new UnicodeRangeTable(decodeRanges("g4FVKA", true)), - Tagbanwa: () => new UnicodeRangeTable(decodeRanges("g7FMCCCB", true)), - Tai_Le: () => new UnicodeRangeTable(decodeRanges("wqGdDE", true)), - Tai_Tham: () => new UnicodeRangeTable(decodeRanges("gxG+BCcDKHJHN", true)), - Tai_Viet: () => new UnicodeRangeTable(decodeRanges("g0qBiCZE", true)), - Takri: () => new UnicodeRangeTable(decodeRanges("g0lC5BHJ", true)), - Tamil: () => - new UnicodeRangeTable( - decodeRanges( - "i8CBBCFBECBCDBEBBCCCBEEBEEBBBELBFEBECBCDBDHHPUBm+kCxBBOAB", - false, - ), - ), - Tangsa: () => new UnicodeRangeTable(decodeRanges("wz6CuCCJ", true)), - Tangut: () => - new UnicodeRangeTable(decodeRanges("g-7CgBgBB2-FBJ-XBhQIB", false)), - Telugu: () => - new UnicodeRangeTable( - decodeRanges("ggDMBCCBCWBCPBDIBCCBCDBIBBCCBDDDBCBDJBIIB", false), - ), - Thaana: () => new UnicodeRangeTable(decodeRanges("g8BxB", true)), - Thai: () => new UnicodeRangeTable(decodeRanges("hwD5BGb", true)), - Tibetan: () => - new UnicodeRangeTable(decodeRanges("g4DnCCjBFmBCjBCOCGFB", true)), - Tifinagh: () => new UnicodeRangeTable(decodeRanges("wpL3BIBPA", true)), - Tirhuta: () => new UnicodeRangeTable(decodeRanges("gklCnCJJ", true)), Todhri: () => new UnicodeRangeTable(decodeRanges("guhCzB", true)), - Toto: () => new UnicodeRangeTable(decodeRanges("w04De", true)), Tulu_Tigalari: () => new UnicodeRangeTable( decodeRanges("g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB", false), ), - Ugaritic: () => new UnicodeRangeTable(decodeRanges("g8gCdCA", true)), - Unknown: () => - new UnicodeRangeTable( - decodeRanges( - "4bBBHDBICCVuMuMnBBBzBBBE4B4BBGBcDBHKBvI9B9BBmDmDBMB8BBByBBBQddBCCMEBgBDDBDBuHJJBDDBXXICCBBBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBbFB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKmDmDNBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBjoIBvLBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCC-FCBHBBHBBHBBECBIIIBIBGBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIBlCJBCBBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMB3iBJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBJ76DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBjGUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEwi3VBCdBhD-DBxHvw-FB", - false, - ), - ), - Vai: () => new UnicodeRangeTable(decodeRanges("gopBrJ", true)), - Vithkuqi: () => - new UnicodeRangeTable(decodeRanges("wrhCKCOCGCBCKCOCGCB", true)), - Wancho: () => new UnicodeRangeTable(decodeRanges("g24D5BGA", true)), - Warang_Citi: () => new UnicodeRangeTable(decodeRanges("glmCyCNA", true)), - Yezidi: () => new UnicodeRangeTable(decodeRanges("g0jCpBCCDB", true)), - Yi: () => new UnicodeRangeTable(decodeRanges("ggoBskBE2B", true)), - Zanabazar_Square: () => new UnicodeRangeTable(decodeRanges("gwmCnC", true)), }); const STABLE_CATEGORY_NAMES: ReadonlySet = new Set([ @@ -640,8 +269,7 @@ const STABLE_CATEGORY_NAMES: ReadonlySet = new Set([ "Zp", "Zs", ]); -const STABLE_SCRIPT_NAMES: ReadonlySet = new Set([]); -const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ +const STABLE_SCRIPT_NAMES: ReadonlySet = new Set([ "Adlam", "Ahom", "Anatolian_Hieroglyphs", @@ -681,7 +309,6 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Elbasan", "Elymaic", "Ethiopic", - "Garay", "Georgian", "Glagolitic", "Gothic", @@ -690,7 +317,6 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Gujarati", "Gunjala_Gondi", "Gurmukhi", - "Gurung_Khema", "Han", "Hangul", "Hanifi_Rohingya", @@ -713,7 +339,6 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Khmer", "Khojki", "Khudawadi", - "Kirat_Rai", "Lao", "Latin", "Lepcha", @@ -751,7 +376,6 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Nyiakeng_Puachue_Hmong", "Ogham", "Ol_Chiki", - "Ol_Onal", "Old_Hungarian", "Old_Italic", "Old_North_Arabian", @@ -783,7 +407,6 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Sora_Sompeng", "Soyombo", "Sundanese", - "Sunuwar", "Syloti_Nagri", "Syriac", "Tagalog", @@ -801,9 +424,7 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Tibetan", "Tifinagh", "Tirhuta", - "Todhri", "Toto", - "Tulu_Tigalari", "Ugaritic", "Unknown", "Vai", @@ -814,6 +435,15 @@ const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ "Yi", "Zanabazar_Square", ]); +const NEW_SCRIPT_NAMES: ReadonlySet = new Set([ + "Garay", + "Gurung_Khema", + "Kirat_Rai", + "Ol_Onal", + "Sunuwar", + "Todhri", + "Tulu_Tigalari", +]); const _sweepCache = new Map(); const _foldCache = new Map(); @@ -967,4 +597,14 @@ export const UnicodeTables = { get Upper(): UnicodeRangeTable { return getUpper(); }, + + // --- Test-only hooks: expose the raw bundled 15.0→16.0 delta and + // new-in-16.0 script data so tests can verify the generator output. + // These are not part of the public API. + _deltaCategoryRanges: (name: string): Uint32Array | null => + _DELTA_CATEGORIES.get(name), + _deltaScriptRanges: (name: string): Uint32Array | null => + _DELTA_SCRIPTS.get(name), + _newScriptTable: (name: string): UnicodeRangeTable | null => + _NEW_SCRIPTS.get(name), }; diff --git a/packages/re2/src/__tests__/UnicodeTableContents.test.ts b/packages/re2/src/__tests__/UnicodeTableContents.test.ts new file mode 100644 index 0000000..02555a9 --- /dev/null +++ b/packages/re2/src/__tests__/UnicodeTableContents.test.ts @@ -0,0 +1,175 @@ +import { describe, test } from "node:test"; +import * as assert from "node:assert/strict"; +import { UnicodeTables } from "../UnicodeTables.js"; +import type { UnicodeRangeTable } from "../UnicodeRangeTable.js"; +// @ts-expect-error - package has no .d.ts +import propertyValueAliases from "unicode-property-value-aliases"; + +const GC_ALIAS_TO_LONG = propertyValueAliases.get("General_Category") as Map< + string, + string +>; + +// Expands either a stride-encoded Uint32Array (triples of lo/hi/stride, as +// returned by _deltaCategoryRanges / _deltaScriptRanges) or a full +// UnicodeRangeTable into a Set of code points. +const expandStrideTriples = (arr: Uint32Array): Set => { + const set = new Set(); + for (let i = 0; i < arr.length; i += 3) { + const lo = arr[i]; + const hi = arr[i + 1]; + const stride = arr[i + 2]; + for (let cp = lo; cp <= hi; cp += stride) set.add(cp); + } + return set; +}; + +const expandTable = (table: UnicodeRangeTable): Set => { + const set = new Set(); + for (let i = 0; i < table.length; i++) { + const lo = table.getLo(i); + const hi = table.getHi(i); + const stride = table.getStride(i); + for (let cp = lo; cp <= hi; cp += stride) set.add(cp); + } + return set; +}; + +const loadCodePoints = async ( + pkg: "@unicode/unicode-15.0.0" | "@unicode/unicode-16.0.0", + property: "General_Category" | "Script", + longName: string, +): Promise | null> => { + try { + const mod = (await import( + `${pkg}/${property}/${longName}/code-points.js` + )) as { default: number[] }; + return new Set(mod.default); + } catch { + return null; + } +}; + +const fmtCp = (cp: number): string => + `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`; + +const diffSets = ( + actual: Set, + expected: Set, +): { missing: number[]; extra: number[] } => { + const missing: number[] = []; + const extra: number[] = []; + for (const cp of expected) if (!actual.has(cp)) missing.push(cp); + for (const cp of actual) if (!expected.has(cp)) extra.push(cp); + missing.sort((a, b) => a - b); + extra.sort((a, b) => a - b); + return { missing, extra }; +}; + +const setDiff = (a: Set, b: Set): Set => { + const out = new Set(); + for (const cp of a) if (!b.has(cp)) out.add(cp); + return out; +}; + +const assertSetsEqual = ( + label: string, + actual: Set, + expected: Set, +): void => { + const { missing, extra } = diffSets(actual, expected); + if (missing.length + extra.length === 0) return; + const previewMissing = missing.slice(0, 5).map(fmtCp).join(", "); + const previewExtra = extra.slice(0, 5).map(fmtCp).join(", "); + assert.fail( + `${label}: missing ${missing.length} [${previewMissing}], extra ${extra.length} [${previewExtra}]`, + ); +}; + +// Validates that the bundled 15→16 delta data equals exactly +// setDiff(unicode16, unicode15) for each stable property name. This +// simulates a Unicode-15 host without requiring one: if the decoded +// delta matches setDiff(16, 15), then on any Unicode 15 engine the +// merged runtime result (sweep(15) ∪ delta) equals Unicode 16.0 for +// every property that is purely additive across the 15→16 transition. +describe("UnicodeTables 15→16 delta matches setDiff(unicode16, unicode15)", () => { + for (const alias of UnicodeTables.STABLE_CATEGORY_NAMES) { + const longName = GC_ALIAS_TO_LONG.get(alias); + test(`category ${alias} (${longName ?? "?"})`, async () => { + assert.ok(longName !== undefined, `no GC long name for ${alias}`); + const cp15 = await loadCodePoints( + "@unicode/unicode-15.0.0", + "General_Category", + longName, + ); + const cp16 = await loadCodePoints( + "@unicode/unicode-16.0.0", + "General_Category", + longName, + ); + assert.ok(cp15, `missing Unicode 15 data for ${longName}`); + assert.ok(cp16, `missing Unicode 16 data for ${longName}`); + + const expectedDelta = setDiff(cp16, cp15); + const decoded = UnicodeTables._deltaCategoryRanges(alias); + const actualDelta = + decoded === null ? new Set() : expandStrideTriples(decoded); + + assertSetsEqual(`delta(${alias})`, actualDelta, expectedDelta); + }); + } + + for (const name of UnicodeTables.STABLE_SCRIPT_NAMES) { + test(`script ${name}`, async () => { + const cp15 = await loadCodePoints( + "@unicode/unicode-15.0.0", + "Script", + name, + ); + const cp16 = await loadCodePoints( + "@unicode/unicode-16.0.0", + "Script", + name, + ); + assert.ok(cp15, `missing Unicode 15 data for script ${name}`); + assert.ok(cp16, `missing Unicode 16 data for script ${name}`); + + const expectedDelta = setDiff(cp16, cp15); + const decoded = UnicodeTables._deltaScriptRanges(name); + const actualDelta = + decoded === null ? new Set() : expandStrideTriples(decoded); + + assertSetsEqual(`delta(${name})`, actualDelta, expectedDelta); + }); + } +}); + +// Scripts introduced in Unicode 16.0 have no 15.0 counterpart, so the +// generator bundles the full table. Validate each full-table equals +// Unicode 16.0 ground truth exactly. +describe("UnicodeTables new-in-16.0 scripts match Unicode 16.0 exactly", () => { + for (const name of UnicodeTables.NEW_SCRIPT_NAMES) { + test(name, async () => { + const cp15 = await loadCodePoints( + "@unicode/unicode-15.0.0", + "Script", + name, + ); + assert.strictEqual( + cp15, + null, + `${name} is listed as new-in-16 but exists in Unicode 15.0`, + ); + const cp16 = await loadCodePoints( + "@unicode/unicode-16.0.0", + "Script", + name, + ); + assert.ok(cp16, `missing Unicode 16 data for script ${name}`); + + const table = UnicodeTables._newScriptTable(name); + assert.ok(table, `_newScriptTable(${name}) returned null`); + assertSetsEqual(`newScript(${name})`, expandTable(table), cp16); + }); + } +}); From dd34db0efe7f670639f9fef12d3c012bd9f84847 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Tue, 21 Apr 2026 13:55:23 -0400 Subject: [PATCH 09/13] fix formatting. remove unused methods, constants, and files. --- packages/cel/package.json | 4 +- packages/cel/src/std/logic.ts | 175 ++++++++++++------------ packages/cel/tsconfig.json | 2 +- packages/re2/scripts/genUnicodeTable.js | 11 +- packages/re2/src/Compiler.ts | 30 ---- packages/re2/src/Parser.ts | 3 - packages/re2/src/Regexp.ts | 8 -- packages/re2/src/Utils.ts | 2 +- packages/re2/src/__utils__/unicode.ts | 14 -- 9 files changed, 97 insertions(+), 152 deletions(-) delete mode 100644 packages/re2/src/__utils__/unicode.ts diff --git a/packages/cel/package.json b/packages/cel/package.json index 1eaeaab..8158de6 100644 --- a/packages/cel/package.json +++ b/packages/cel/package.json @@ -44,9 +44,7 @@ }, "typesVersions": { "*": { - "ext": [ - "./dist/cjs/ext/index.d.ts" - ] + "ext": ["./dist/cjs/ext/index.d.ts"] } }, "peerDependencies": { diff --git a/packages/cel/src/std/logic.ts b/packages/cel/src/std/logic.ts index 56685ab..58a30ee 100644 --- a/packages/cel/src/std/logic.ts +++ b/packages/cel/src/std/logic.ts @@ -15,18 +15,18 @@ import * as opc from "../gen/dev/cel/expr/operator_const.js"; import * as olc from "../gen/dev/cel/expr/overload_const.js"; import { - CelScalar, - DURATION, - listType, - mapType, - TIMESTAMP, - type CelValue, + CelScalar, + DURATION, + listType, + mapType, + TIMESTAMP, + type CelValue, } from "../type.js"; -import {equals} from "../equals.js"; -import {celMethod, celFunc} from "../func.js"; -import type {CelList} from "../list.js"; -import type {CelMap} from "../map.js"; -import {RE2JS} from "@bufbuild/re2"; +import { equals } from "../equals.js"; +import { celMethod, celFunc } from "../func.js"; +import type { CelList } from "../list.js"; +import type { CelMap } from "../map.js"; +import { RE2JS } from "@bufbuild/re2"; /** * Patterns that are supported in ECMAScript RE and not in @@ -36,111 +36,110 @@ import {RE2JS} from "@bufbuild/re2"; * RE2: https://github.com/google/re2/wiki/syntax */ const invalidPatterns = [ - /\\[1-9]/, // backreference eg: \1 - /\\k<.>/, // backreference eg: \k - /\(\?\=/, // lookahead eg: Jack(?=Sprat) - /\(\?\!/, // negative lookahead eg: Jack(?!Sprat) - /\(\?\<\=/, // lookbehind eg: (?<=Sprat)Jack - /\(\?\<\!/, // negative lookbehind eg: (?/, // backreference eg: \k + /\(\?\=/, // lookahead eg: Jack(?=Sprat) + /\(\?\!/, // negative lookahead eg: Jack(?!Sprat) + /\(\?\<\=/, // lookbehind eg: (?<=Sprat)Jack + /\(\?\<\!/, // negative lookbehind eg: (?[ims\-]+)\)/); -const flagMappings = new Map(). - set("i", RE2JS.CASE_INSENSITIVE). - set("m", RE2JS.MULTILINE). - set("s", RE2JS.DOTALL); +const flagMappings = new Map() + .set("i", RE2JS.CASE_INSENSITIVE) + .set("m", RE2JS.MULTILINE) + .set("s", RE2JS.DOTALL); export function matches(this: string, pattern: string): boolean { - - // can probably delete this since the RE2 engine will already reject them, but keep for now - for (const invalidPattern of invalidPatterns) { - if (invalidPattern.test(pattern)) { - throw new Error( - `Error evaluating pattern ${pattern}, invalid RE2 syntax`, - ); - } + // can probably delete this since the RE2 engine will already reject them, but keep for now + for (const invalidPattern of invalidPatterns) { + if (invalidPattern.test(pattern)) { + throw new Error( + `Error evaluating pattern ${pattern}, invalid RE2 syntax`, + ); } - // CEL use RE2 syntax which is a subset of Ecmascript RE except for - // the flags and the ability to change the flags mid-sequence. - // - // The conformance tests use flags at the very beginning of the sequence, which - // is likely the most common place where this rare feature will be used. - // - // Instead of importing an RE2 engine to be able to support this niche, we - // can instead just check for the flags at the very beginning and apply them. - // - // Unsupported flags and flags mid-sequence will fail with to compile the regex. - // - // Users can choose to override this function and provide an RE2 engine if they really - // need to. - let flagVal = 0; - const flagMatches = pattern.match(flagPattern); - if (flagMatches) { - for (let flag of flagMatches?.groups?.flags ?? "") { - if (flag == "-") { - break; - } - flagVal |= flagMappings.get(flag) ?? 0; - } - pattern = pattern.substring(flagMatches[0].length); + } + // CEL use RE2 syntax which is a subset of Ecmascript RE except for + // the flags and the ability to change the flags mid-sequence. + // + // The conformance tests use flags at the very beginning of the sequence, which + // is likely the most common place where this rare feature will be used. + // + // Instead of importing an RE2 engine to be able to support this niche, we + // can instead just check for the flags at the very beginning and apply them. + // + // Unsupported flags and flags mid-sequence will fail with to compile the regex. + // + // Users can choose to override this function and provide an RE2 engine if they really + // need to. + let flagVal = 0; + const flagMatches = pattern.match(flagPattern); + if (flagMatches) { + for (let flag of flagMatches?.groups?.flags ?? "") { + if (flag == "-") { + break; + } + flagVal |= flagMappings.get(flag) ?? 0; } - const re: RE2JS = RE2JS.compile(pattern, flagVal); - //const re = new RegExp(pattern, flags); - return re.test(this); + pattern = pattern.substring(flagMatches[0].length); + } + const re: RE2JS = RE2JS.compile(pattern, flagVal); + //const re = new RegExp(pattern, flags); + return re.test(this); } function compareDuration( - lhs: CelValue, - rhs: CelValue, + lhs: CelValue, + rhs: CelValue, ) { - const cmp = lhs.message.seconds - rhs.message.seconds; - if (cmp == 0n) { - return lhs.message.nanos - rhs.message.nanos; - } - return cmp < 0n ? -1 : 1; + const cmp = lhs.message.seconds - rhs.message.seconds; + if (cmp == 0n) { + return lhs.message.nanos - rhs.message.nanos; + } + return cmp < 0n ? -1 : 1; } function compareTimestamp( - lhs: CelValue, - rhs: CelValue, + lhs: CelValue, + rhs: CelValue, ) { - const cmp = lhs.message.seconds - rhs.message.seconds; - if (cmp == 0n) { - return lhs.message.nanos - rhs.message.nanos; - } - return cmp < 0n ? -1 : 1; + const cmp = lhs.message.seconds - rhs.message.seconds; + if (cmp == 0n) { + return lhs.message.nanos - rhs.message.nanos; + } + return cmp < 0n ? -1 : 1; } function compareBytes(lhs: Uint8Array, rhs: Uint8Array): number { - const minLen = Math.min(lhs.length, rhs.length); - for (let i = 0; i < minLen; i++) { - if (lhs[i] < rhs[i]) { - return -1; - } - if (lhs[i] > rhs[i]) { - return 1; - } + const minLen = Math.min(lhs.length, rhs.length); + for (let i = 0; i < minLen; i++) { + if (lhs[i] < rhs[i]) { + return -1; } - return lhs.length - rhs.length; + if (lhs[i] > rhs[i]) { + return 1; + } + } + return lhs.length - rhs.length; } function inList(value: CelValue, list: CelList) { - for (const v of list) { - if (equals(v, value)) return true; - } - return false; + for (const v of list) { + if (equals(v, value)) return true; + } + return false; } function inMap[0]>(value: T, map: CelMap) { - return map.has(value); + return map.has(value); } -const {BOOL, BYTES, DOUBLE, DYN, INT, STRING, UINT} = CelScalar; +const { BOOL, BYTES, DOUBLE, DYN, INT, STRING, UINT } = CelScalar; const LIST = listType(CelScalar.DYN); const MAP = mapType(CelScalar.DYN, CelScalar.DYN); diff --git a/packages/cel/tsconfig.json b/packages/cel/tsconfig.json index 3ae4550..b02b721 100644 --- a/packages/cel/tsconfig.json +++ b/packages/cel/tsconfig.json @@ -1,5 +1,5 @@ { "files": ["src/index.ts", "src/ext/index.ts"], "extends": "../../tsconfig.base.json", - "include": ["src/**/*.test.ts"], + "include": ["src/**/*.test.ts"] } diff --git a/packages/re2/scripts/genUnicodeTable.js b/packages/re2/scripts/genUnicodeTable.js index ed67625..a4aa9c8 100644 --- a/packages/re2/scripts/genUnicodeTable.js +++ b/packages/re2/scripts/genUnicodeTable.js @@ -37,13 +37,16 @@ const generateCaseFoldOrbits = () => { for (let [key, value] of orbits) { let orbitWithKey = new Set(value); orbitWithKey.add(key); - orbitWithKey = Array.from(orbitWithKey).sort((a, b) => a - b); - let a = orbitWithKey[0]; - for (let i of orbitWithKey.slice(1)) { + const orbitWithKeyArray = Array.from(orbitWithKey).sort((a, b) => a - b); + let a = orbitWithKeyArray[0]; + for (let i of orbitWithKeyArray.slice(1)) { finalResult.set(a, i); a = i; } - finalResult.set(orbitWithKey[orbitWithKey.length - 1], orbitWithKey[0]); + finalResult.set( + orbitWithKeyArray[orbitWithKeyArray.length - 1], + orbitWithKeyArray[0], + ); } return finalResult; }; diff --git a/packages/re2/src/Compiler.ts b/packages/re2/src/Compiler.ts index eb531d8..d4e0655 100644 --- a/packages/re2/src/Compiler.ts +++ b/packages/re2/src/Compiler.ts @@ -55,36 +55,6 @@ class Compiler { return c.prog; } - static compileSet(regexps: Regexp[]): Prog { - const c = new Compiler(); - - if (regexps.length === 0) { - c.prog.start = c.newInst(Inst.FAIL).i; - return c.prog; - } - - let starts = []; - for (let i = 0; i < regexps.length; i++) { - const f = c.compile(regexps[i]); - const m = c.newInst(Inst.MATCH); - c.prog.getInst(m.i).arg = i; // Store the regex index - c.prog.patch(f.out, m.i); - starts.push(f.i); - } - - // Link starts together via ALT - let start = starts[0]; - for (let i = 1; i < starts.length; i++) { - const f = c.newInst(Inst.ALT); - const inst = c.prog.getInst(f.i); - inst.out = start; - inst.arg = starts[i]; - start = f.i; - } - c.prog.start = start; - return c.prog; - } - constructor() { this.prog = new Prog(); this.newInst(Inst.FAIL); diff --git a/packages/re2/src/Parser.ts b/packages/re2/src/Parser.ts index ab9c08e..f15b7e4 100644 --- a/packages/re2/src/Parser.ts +++ b/packages/re2/src/Parser.ts @@ -121,9 +121,6 @@ class StringIterator { * The only public entry point is {@link #parse(String pattern, int flags)}. */ class Parser { - // Unexpected error - static ERR_INTERNAL_ERROR = "regexp/syntax: internal error"; - // Parse errors static ERR_INVALID_CHAR_RANGE = "invalid character class range"; static ERR_INVALID_ESCAPE = "invalid escape sequence"; diff --git a/packages/re2/src/Regexp.ts b/packages/re2/src/Regexp.ts index 0370c84..1a00b56 100644 --- a/packages/re2/src/Regexp.ts +++ b/packages/re2/src/Regexp.ts @@ -33,14 +33,6 @@ export class Regexp { static emptySubs(): Regexp[] { return []; } - - static quoteIfHyphen(rune: number): string { - if (rune === 0x2d) { - return "\\"; - } - return ""; - } - static fromRegexp(re: Regexp): Regexp { const regex = new Regexp(re.op); regex.flags = re.flags; diff --git a/packages/re2/src/Utils.ts b/packages/re2/src/Utils.ts index 668e384..fe4cb33 100644 --- a/packages/re2/src/Utils.ts +++ b/packages/re2/src/Utils.ts @@ -96,7 +96,7 @@ function emptyOpContext(r1: number, r2: number): number { * Returns a string that quotes all regular expression metacharacters inside the argument text; * the returned string is a regular expression matching the literal text. For example, * {@code quoteMeta("[foo]").equals("\\[foo\\]")}. - * @param {string} s + * @param {string} str * @returns {string} */ function quoteMeta(str: string): string { diff --git a/packages/re2/src/__utils__/unicode.ts b/packages/re2/src/__utils__/unicode.ts deleted file mode 100644 index 9c57dfc..0000000 --- a/packages/re2/src/__utils__/unicode.ts +++ /dev/null @@ -1,14 +0,0 @@ -const encoder = new TextEncoder(); - -export const utf16IndicesToUtf8 = (idx16: number[], text: string): number[] => { - const idx8: number[] = new Array(idx16.length); - for (let i = 0; i < idx16.length; ++i) { - if (idx16[i] === -1) { - idx8[i] = -1; - } else { - const subText = text.substring(0, idx16[i]); - idx8[i] = encoder.encode(subText).length; - } - } - return idx8; -}; From cccca4684841e97739b1ceb712d2f639d5b6de40 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Tue, 21 Apr 2026 13:59:08 -0400 Subject: [PATCH 10/13] revert import change in checker.test.ts --- packages/cel/src/checker.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/cel/src/checker.test.ts b/packages/cel/src/checker.test.ts index 2005ca4..6fb6ad3 100644 --- a/packages/cel/src/checker.test.ts +++ b/packages/cel/src/checker.test.ts @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -import { getCheckingSuite } from "../../cel-spec/dist/cjs/testdata/tests.js"; +import { getCheckingSuite } from "@bufbuild/cel-spec/testdata/tests.js"; import { createExpressionFilter, runCheckingTest, From 1fc17e88457c531861c2ea1dcc40c7b96e429407 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Tue, 21 Apr 2026 14:24:40 -0400 Subject: [PATCH 11/13] don't put license headers on the re2 files --- packages/re2/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/re2/package.json b/packages/re2/package.json index 08fc3d4..2da557a 100644 --- a/packages/re2/package.json +++ b/packages/re2/package.json @@ -24,7 +24,7 @@ "format": "biome format --write", "lint": "biome lint --error-on-warnings", "attw": "attw --pack", - "license-header": "license-header" + "license-header": "license-header --ignore 'src/**' --ignore 'scripts/**'" }, "licenseHeader": { "licenseType": "MIT", From 68ce0a30dc30c49f86057f858a052e007dbff978 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Fri, 24 Apr 2026 19:00:04 -0400 Subject: [PATCH 12/13] updates for PR --- package-lock.json | 125 ++++++++++------------- packages/cel/package.json | 4 +- packages/cel/src/std/logic.ts | 62 +---------- packages/re2/src/__tests__/index.test.ts | 7 ++ 4 files changed, 64 insertions(+), 134 deletions(-) diff --git a/package-lock.json b/package-lock.json index 9c31925..aec9f76 100644 --- a/package-lock.json +++ b/package-lock.json @@ -937,29 +937,6 @@ "node": ">=18" } }, - "node_modules/@isaacs/balanced-match": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/@isaacs/balanced-match/-/balanced-match-4.0.1.tgz", - "integrity": "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": "20 || >=22" - } - }, - "node_modules/@isaacs/brace-expansion": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/@isaacs/brace-expansion/-/brace-expansion-5.0.0.tgz", - "integrity": "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==", - "dev": true, - "license": "MIT", - "dependencies": { - "@isaacs/balanced-match": "^4.0.1" - }, - "engines": { - "node": "20 || >=22" - } - }, "node_modules/@loaderkit/resolve": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/@loaderkit/resolve/-/resolve-1.0.4.tgz", @@ -971,31 +948,18 @@ } }, "node_modules/@peggyjs/from-mem": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@peggyjs/from-mem/-/from-mem-3.1.1.tgz", - "integrity": "sha512-m5OEjgJaePWpyNtQCvRZkpLoV+z44eh6QIO9yEwQuOThdUdkECO3wcKLT3tFA3H8WM5bxU/K/dpmo7r/X16UEw==", + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@peggyjs/from-mem/-/from-mem-3.1.3.tgz", + "integrity": "sha512-LLlgtfXIaeYXoOYovOI0spLM8ZXaqkAlmcRRrLzHJzLMqkU6Sw0R4KMoCoHx1PjaP815pSCBlS+BN6aD8t1Jgg==", "dev": true, "license": "MIT", "dependencies": { - "semver": "7.7.2" + "semver": "7.7.4" }, "engines": { "node": ">=20.8" } }, - "node_modules/@peggyjs/from-mem/node_modules/semver": { - "version": "7.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", - "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, "node_modules/@sindresorhus/is": { "version": "4.6.0", "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz", @@ -1110,6 +1074,29 @@ "dev": true, "license": "MIT" }, + "node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/brace-expansion": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz", + "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, "node_modules/chalk": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", @@ -1476,16 +1463,16 @@ } }, "node_modules/minimatch": { - "version": "10.1.1", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz", - "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==", + "version": "10.2.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", + "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { - "@isaacs/brace-expansion": "^5.0.0" + "brace-expansion": "^5.0.5" }, "engines": { - "node": "20 || >=22" + "node": "18 || 20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" @@ -1568,15 +1555,15 @@ "license": "MIT" }, "node_modules/peggy": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/peggy/-/peggy-5.0.6.tgz", - "integrity": "sha512-Sud8Zus0JAgE+U4zwkJv29OOaXhviFI7J90/6cGfy3OoqR8dpnieeF9a46dj0bTtqiFnrFatldA6ltQyOJvNmg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/peggy/-/peggy-5.1.0.tgz", + "integrity": "sha512-IEo5aYRZ2kXH4Qby06cjtL114PZnwLoTiA41vUmg2vPZgANn+c87m5BUurhuDr5/cu758ZlpgsAfBVx+hhO5+w==", "dev": true, "license": "MIT", "dependencies": { - "@peggyjs/from-mem": "3.1.1", - "commander": "^14.0.0", - "source-map-generator": "2.0.2" + "@peggyjs/from-mem": "3.1.3", + "commander": "^14.0.3", + "source-map-generator": "2.0.6" }, "bin": { "peggy": "bin/peggy.js" @@ -1599,9 +1586,9 @@ } }, "node_modules/peggy/node_modules/commander": { - "version": "14.0.2", - "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.2.tgz", - "integrity": "sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ==", + "version": "14.0.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz", + "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==", "dev": true, "license": "MIT", "engines": { @@ -1642,9 +1629,9 @@ } }, "node_modules/semver": { - "version": "7.7.3", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", - "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", "dev": true, "license": "ISC", "bin": { @@ -1668,9 +1655,9 @@ } }, "node_modules/source-map-generator": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/source-map-generator/-/source-map-generator-2.0.2.tgz", - "integrity": "sha512-unCl5BQhF/us51DiT7SvlSY3QUPhyfAdHJxd8l7FXdwzqxli0UDMV2dEuei2SeGp3Z4rB/AJ9zKi1mGOp2K2ww==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/source-map-generator/-/source-map-generator-2.0.6.tgz", + "integrity": "sha512-IlassDs1Ve8nV6uyQZXF9kdkJpVKnMte2JZQXu13M0A5zwc+vu6+LNHfmxsHBMDtoZE21RHiKI0/xvpecZRCNg==", "dev": true, "license": "BSD-3-Clause", "engines": { @@ -1769,14 +1756,14 @@ } }, "node_modules/tinyglobby": { - "version": "0.2.15", - "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", - "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "version": "0.2.16", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz", + "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", "dev": true, "license": "MIT", "dependencies": { "fdir": "^6.5.0", - "picomatch": "^4.0.3" + "picomatch": "^4.0.4" }, "engines": { "node": ">=12.0.0" @@ -1804,9 +1791,9 @@ } }, "node_modules/tinyglobby/node_modules/picomatch": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", "dev": true, "license": "MIT", "engines": { @@ -2066,11 +2053,9 @@ "@bufbuild/re2": "0.4.0" }, "devDependencies": { - "@unicode/unicode-16.0.0": "^1.6.16", "expect-type": "^1.3.0", "peggy": "^5.0.6", - "peggy-ts": "github:hudlow/peggy-ts#v0.0.9", - "unicode-property-value-aliases": "^3.9.0" + "peggy-ts": "github:hudlow/peggy-ts#v0.0.9" }, "peerDependencies": { "@bufbuild/protobuf": "^2.6.2" diff --git a/packages/cel/package.json b/packages/cel/package.json index 8158de6..3520bec 100644 --- a/packages/cel/package.json +++ b/packages/cel/package.json @@ -55,10 +55,8 @@ "@bufbuild/re2": "0.4.0" }, "devDependencies": { - "@unicode/unicode-16.0.0": "^1.6.16", "expect-type": "^1.3.0", "peggy": "^5.0.6", - "peggy-ts": "github:hudlow/peggy-ts#v0.0.9", - "unicode-property-value-aliases": "^3.9.0" + "peggy-ts": "github:hudlow/peggy-ts#v0.0.9" } } diff --git a/packages/cel/src/std/logic.ts b/packages/cel/src/std/logic.ts index 58a30ee..5f62162 100644 --- a/packages/cel/src/std/logic.ts +++ b/packages/cel/src/std/logic.ts @@ -28,68 +28,8 @@ import type { CelList } from "../list.js"; import type { CelMap } from "../map.js"; import { RE2JS } from "@bufbuild/re2"; -/** - * Patterns that are supported in ECMAScript RE and not in - * RE2. - * - * ECMAScript Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Cheatsheet - * RE2: https://github.com/google/re2/wiki/syntax - */ -const invalidPatterns = [ - /\\[1-9]/, // backreference eg: \1 - /\\k<.>/, // backreference eg: \k - /\(\?\=/, // lookahead eg: Jack(?=Sprat) - /\(\?\!/, // negative lookahead eg: Jack(?!Sprat) - /\(\?\<\=/, // lookbehind eg: (?<=Sprat)Jack - /\(\?\<\!/, // negative lookbehind eg: (?[ims\-]+)\)/); - -const flagMappings = new Map() - .set("i", RE2JS.CASE_INSENSITIVE) - .set("m", RE2JS.MULTILINE) - .set("s", RE2JS.DOTALL); - export function matches(this: string, pattern: string): boolean { - // can probably delete this since the RE2 engine will already reject them, but keep for now - for (const invalidPattern of invalidPatterns) { - if (invalidPattern.test(pattern)) { - throw new Error( - `Error evaluating pattern ${pattern}, invalid RE2 syntax`, - ); - } - } - // CEL use RE2 syntax which is a subset of Ecmascript RE except for - // the flags and the ability to change the flags mid-sequence. - // - // The conformance tests use flags at the very beginning of the sequence, which - // is likely the most common place where this rare feature will be used. - // - // Instead of importing an RE2 engine to be able to support this niche, we - // can instead just check for the flags at the very beginning and apply them. - // - // Unsupported flags and flags mid-sequence will fail with to compile the regex. - // - // Users can choose to override this function and provide an RE2 engine if they really - // need to. - let flagVal = 0; - const flagMatches = pattern.match(flagPattern); - if (flagMatches) { - for (let flag of flagMatches?.groups?.flags ?? "") { - if (flag == "-") { - break; - } - flagVal |= flagMappings.get(flag) ?? 0; - } - pattern = pattern.substring(flagMatches[0].length); - } - const re: RE2JS = RE2JS.compile(pattern, flagVal); - //const re = new RegExp(pattern, flags); + const re: RE2JS = RE2JS.compile(pattern); return re.test(this); } diff --git a/packages/re2/src/__tests__/index.test.ts b/packages/re2/src/__tests__/index.test.ts index bf0e6c8..6cd52bc 100644 --- a/packages/re2/src/__tests__/index.test.ts +++ b/packages/re2/src/__tests__/index.test.ts @@ -233,4 +233,11 @@ describe("Core Unicode Properties (Ascii, Assigned, Lc)", () => { const unassignedChar = String.fromCodePoint(0x0378); assert.strictEqual(p.matches(unassignedChar), false); }); + + it("matches case insensitive correctly", () => { + const p = RE2JS.compile("(?i)^hello$"); + assert.strictEqual(p.matches("hello"), true); + assert.strictEqual(p.matches("HELLO"), true); + assert.strictEqual(p.matches("HELlo"), true); + }); }); From af392001e9e0a6b3a04d82313209903c5352b2a9 Mon Sep 17 00:00:00 2001 From: Jon Bodner Date: Tue, 28 Apr 2026 14:46:59 -0400 Subject: [PATCH 13/13] remove unneeded dependency from root package.json. --- package-lock.json | 3 --- package.json | 3 --- 2 files changed, 6 deletions(-) diff --git a/package-lock.json b/package-lock.json index aec9f76..0e471d0 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10,9 +10,6 @@ "packages/example", "packages/re2" ], - "dependencies": { - "@bufbuild/re2": "^0.1.0" - }, "devDependencies": { "@arethetypeswrong/cli": "^0.18.2", "@biomejs/biome": "^1.9.4", diff --git a/package.json b/package.json index cf3821f..35c2ecb 100644 --- a/package.json +++ b/package.json @@ -33,8 +33,5 @@ "tsx": "^4.21.0", "turbo": "^2.8.1", "typescript": "^5.9.3" - }, - "dependencies": { - "@bufbuild/re2": "^0.1.0" } }

b)P^%=3i>FBK25)w?wb~Dgd|FxdYA_%4FD)-CO+7wE+i3FOD&)v} zcihw%a^7jw8(ZS+grP5dsFi=?o(MS>5xuL(>U!JnDiGI!((9ql$Msd>D4X~LCZ0Hb z<{yt$FV*KA(Dt}3^Zm(itojCM=y*(=s((@&tCo^|YDMABlQ@yks*4&EU2Nx+toILC zL3B_um_FgGTI-Pv?BjfxlCh5gRbwCHW6x&c^zMDR`T2;xuZY~V$B*ruAKMu0;|Q2k zoIjjbZAf~f<#uX%BO!K-@5)S;#?Y;hgqRlQ;AP~E4wxZdVfy<+N6#TZc$r#2jhapzlW z*iDteP*pE0O+{>~fDzAepAN3Yfd4qupW|iST@9FY9jc-LQ#aRQ24Grm*v*l_sDt@t z{?m{Hm#bJ%-S`8pP_C8tPZS)T=cgX*hDql=xY8p!A!Ka- z7GIEP$5$GmQshaVh>rSpJFZ?V!lBgAyK&26PiFo>gqrnZ{cVA`YX#Cx0!X)JAl-O? z=#+$HsTk;}gyi2_(9uj$2m&}yfuz(2l2Q#w${ip&tz$rkCg>0X9iC9f6T1C|{a+3P zRwQ7Z2a?hS5}n+j!vS>ULmdsEgAk;fQ6J6`2sUX$kY-fNa7^HNpSS5{)R_oH# zgDQ$!7*cTuzmKbYtBnY(4zh)h@Eox#j$AV*Of=#?M2&kNl#M8iWCh=g5zp(+PL&LM zeYMWGuzo~h9>~{%`BDx!P|n6c&qY_Vb9Y11#8h_JMApPacKEui$#vObV_6ep*GSLs=6;+2L!lCf9N{4}^Y$gw;EY0q0uHM~&5W%KB7;W0cir#is;ARUCBbJtJ;) zc(DbTW^%3xfgusfYEAK}J77qk-ZS}D$1YpUGk~gy!Kzp5h|lMrVsd!lZ2@3LiJ zvN_k4>T@V@{d zj3gE;$>Q;4H7hE&w!C}>ISIMkgaTeXMq%7bPM6SKQw@?0Yy!3#mp*Wv`>ZpMV_#U& z-#x^8cOLNso#0y@ku1Do&=pnwX7U`tW=BQleqts%K{YeqM+kK5RJ^H$x;11ro_#XY zLQFRlux#f|3lI0}93}cg!!hRwzY_}>#;?mqz&j@x4RlHZFWs}tn>4PFokr?##DG6?dGmUpHT33;NZA=^J8D{YEB=7 zyqKS4o@~}g9CjP_WD#Kz`GTI8S86~F29g)>adeCLE)sZWdTI_6`X6#S;$=4}6O*?V zy|kjund(`Q9ia%TdOnvi#xu)Q)ms6kxDThc18%NRO*Zi*2_qfj=RVxIN2L=Z=dS0F zI(pSzi^-HfFcot+SLP8|an~vHJp;6>RkAUu1`Zv0GMwF9^fL@?fOcv&!)g}s=}jME z)Tnf37!IvdMtG7j?9U`5CRniN9wi^|0RaaNU z+&Bg!?jzMI!zxt}5*4pchThdh6q8BX&xP%5Eqmirl2M{=z6~pFIuE5DO6?A(nDO=W zk2dXZ=L3~Hcq?t^ZV)nk@4g~mjFQNYMXuU5WJD2rM%)ZcX8|-ry3(?W9q%yrb~aY& zyV984c;@mvpjfO+%-1;~*F|C1#cWB-=ib;;(>oqt)>mUEt_uZw#Ixb8_11*7oVu?+ zG>}3*T}>6y?q(CteOC4hHa|-?8PG2tg?bnr5$#`*0(TBwZfyT$Vp61DV>&AHBFB|w z;itc%Y?Sg znZqLZC$ZBS`rJ~{`M1)=! z!dR`VNn^5;@Iv_Rvivx20V~l$oOU`^B|ld-blFu+3O_s>{tJHiYq-r$W#7RoJC$Vz zd)C~LmX~K~dOVc`ky44;(<8)Wt)`K7A^n|A_`hTV{&K>bvc3!()4bow6=0B%JJU#a|?NCu#Hw{%MsU@KdfVj-bEKgjqt{7c*hP(Du$u*yQr!2$4r-e9YP#FgQ8$WEXa= zmAkVL!MQp~h^Ew{!Kn^~hh;DA?N@#h8`XY-eT)KKb8QP((xck&rp%0Hyx*YVjo5y3 zcO`|9S=NeO&u{44{@=dV53n3K?vF6kMB5)~=QkCjc`NiO;Tyr$pEz9Zeh>eu8uuP# zv|=wM#tGYR2s^)QZH|%IjgjlYey2&oi&XRoDTXyirCZ+pa`qkW*qJ^d#U#)~f@THo zSVg~(;w#XM1IIw+)A1)7DRSp`PF3MsaLW+P};gVA9j#Uaof0nHjPiV;$r1I-9^{rG`>ZU{K_6tXHSE1MXt;zQz2p5N>VucZ zk#*Y=Tv*m9NEPY9Z#-koV!Nbws)_n*my2P)i$TB3m3|lfeiz+-7oC0=t$r8Heiw~? z7xjLZ^ZhPo`(0F?V;F^wq;;F=6S6l0D60AFKGUo>yiGNDMp0dKV(P^m6^D~_o_7s9 zyqf(@ud}aV!B8AUb>)ev?_fxb&eO-RW4HO1#P>iwq}DbH!^pnw`&vY}d$&0qW5&Kt zc$>2scfJ~ZVg`RlcTp_N6KVK2L$-+`!Vsv2IH7l~8vUwgx7p~QY;3cVULT((EEg>% zHnNU~G9!aXSa_DWg^Lj~M~>tf`c?rjYmRE{PS>p@}xGbCvwBuROT#IJ`eT zjrNshC!6GX4BHyH;%K>W2MqwIxjTq{sIlDn;0Ew2Atv@N6ehYe5YEYQh;0w&RLQr) z+0S_%fNsXIy;1MmjseiSd!Zr|j0f*ORPvH*qej}YEEu0{2ZwXhJFgw`i(c;nKFfTqSGAV-2$WD5bls(j}ucSD} zc%4SYyo2*j%<6j|)ndy0H=T#5VJ8lj!MNgsqN+>q*M;Xs<4|n`zmdZax-N^F*6O(!x+`VJL$BinK>J@ezfPJBheahZRer$=9{_vHJ{_*`)zcOPQ<6sup}o z}CKLJOUew|P_$hvgpN9>Unq!x(!2xQ8(I_^=oVa4*0p{*>ds_QK6y#O9*C zYcHGj>))dXDRzms*dfS`E(Ey|QUQ>g)6@{;Mh=49gg<~FH?$Ds=AkkKxuJw0H{pK0 zYhFyO5J;aMVC>CVkPvWw3j)q}Lcn=)0JJ~L;spWcJ0RfvIRLTO(fC%9h2&y(0~mdQ zIV096jc%~NkP6s8t_}d}eOT`0hcIf?l@z3ug2XsRtoyg!+OU^|k;!k>hr@SDfLki- zJ6Pz}c{ZPk39Pe!mlYg#Ke(X2jeFWHFQO)#FcOB{Oy3T$A{>XVuW=m?%`M_UZd!|F#zfO z=YZwc|Btn=0E?>Y8Wm}2q#LCK1remBB}7UosX+w>1WD-_1nH6zkOm0_L`tMZN|01q zx{(;VVeUR-ynf&R-RJ)IzxQE1bLO1A*FJ|?d&ORRt#!=5dV}!%PBoBd2#Yb#O;bld z2(0+ObL)C55T*0d615>PjY_m^rLf3GN}ac6ufcoIcJ1)NTlOb$R&6e@j`C-39j+X# zg;wgY&V>6v-}_;xvdBFcjjT(s!Z(`N-yG9*ypoY`s8VtU6 zy`Nfv67a@^PAtVxDJTf7zv|PE$*#nFJ2N7cSenAETLX-Rqlt196;c_ zNxeGDSJei45>vm(iRe{7eUPxye6=!k%ape(rsBixf$3|ap}B2(60eIa`g8?<@c15v zq}N?|Qxx=rM}LR1@GwNp>t=3UrY@{kz3##R*~X2=S)OR-sEIzeP0F^&AY|q3pO@8t z@X+m0hNH3bAneS;5FM|Z`E{9hVZE=57W;L#V~Ui#}J!)Rcn_kO3xCYlgBNmm65=|QjH-#! z6ZzUWr#iHYG{@TCy7c|hE9=~_lB5gmHn%{SYWhm9r$fSY+x=Ud-FHRYQcK#tP^cQ` zm~L90<46;Xw?+fuOO=32@weUbW^?S@+3zxOS6YhCMQ0>AD8H^}BZ)J-^MkKVjy*p1 zP-Ro2jXnD`T0-kznsNh5*vobf(%*(?GM>#e#|QCcc*S3MK0{n3Z7 z1{>?giHqVJ)z@wo1q>!l?L2U;r8X||A2gWSx#L=U-ni)5ApO*itZOZaagpEP_er^| zx7nJ5nH3GVwM3GOkJn{v{Yc#DJ$t@S`i}H!Jehyb z#%q$v)%T#q>?-UBHpO)NTWQucE!MY`cs4$Yml=YaGdYsS?%vb+W;Rq!=EQlNOfbqV<*PO-i9Ex5`VxH_me=y$HV4CzTqFT zHa<7(F;|F%KT3LzQwZj_7TpU|2$x)nxuJ#-t^jd4k2jY+*ZVm*>)y3t#{+*VwDYJ4 z+^1B)eJTdIPoIMeQsBZa6k-FSb1WkW#y?z@yL_7zH1LClI?ylzh2e*Q3ztsCkse!6 za1J>&L-D(8R?xv4>HuPKmZ0DqT5!P_T+oLuK*2d=-cl59`^HC&uk1EP1uhl1-O;ng z(K6{J%lpXq=41bbk98PW4N)wYV>TCRk@n%#r zu3CG}M!Qm6drd8_T6bO(yQBpxsMnt}f33wmrt9ez+FLslBEE;S#?Ym5CF7 zqJcQ5WJv)!xLrAT6_S~pdzk{-ep&vO8+dF_nal?G_s zyAZC2_L?_;R{X+>%T{7Vg&z`=&pZ~9=4Um(+1CvmXi%;;^IPPH&4L?CJ5N@}o-B_& zSu*+>dMaq-COqaUY~(6D<|1t5B0T0SY~(CF<|J(7lq)6x`&L8szF%@c=ul~S(s%eWC=6=(pPyB3_F*(i73($n6P|JDs$4$_5&N@l? zDEsuKpuVwot}ym{_q!%wbNT=J;0$7rjP8CtozZPZ<)4qRROSIy82BCoU$6pCb%OS)tztY=RGY+C#O&RPSxy z`=2D~@;$;gy7H*aCI2QcAYjh?HRYe+$KCMK@S=jHx|0br#(1Yu+tCjK9<#Kkw5MZ4 zs5F`rsoiOq>Qr40UeRvy$qnYcvsLTCCpYe1#CoyiIqA!cSMcM+6w33mVY0Iktt36-(?pXOA{7&nux4z0oGR8%oNTGX7j_;FRmOhsFLAXJ<;c}x1HHoLL(CP|X zb*(4PZyf)!JLzs`&(3$e^5eSGo8N{32QUn}3pt|qqV_sdKe~F*ADLV)$((L>-)nb! zorK~oyRkw)aw=d1+hTgXjZ#bSes%Ta_Wi?*PftQF+-~Li^dv&|azv_Oj~{`%jZEZ~ z#n;$3%F^Lf+n;??_3*;Qk`z+H!58-jtc$_^>6}#1)&Ks9&<|@mCn3=PN3ee$Csk&u zUeN#5iH`c^vgQ-zn9>7_C#E8PR{~1EhA0=nx+?A3BDOCshIY&St1%k-m4= zkz-eGS$7_NebMJSH(rzG_7R3cmK;TlxlGi37c;K-{xTye;|M2UtzE&!SzW+8vNLiu z^##Ee>SXwIe;Ad>xyPwE519h&JR)b@Lh2rdmAOZFJ766zO|;bybRxRHpDdW_U8SL- zp_JUCsSOBpcg!~)6=M&iV|ZkfSDcX(Ku7n;JTEGPBY=+Pk#U}VMvgxn)gv96mzQ{e zPQTWnQ~EyvwbG8!a>IknIL6fKvEwcEE)uW_J4V7|G18BW`jDGD&j~lusju%u7{E|v zgm`Imq%=0)(1?V#b=o7+B#seIpN%-pMPlf*9#U%R27!}(>~Br%oe+e0(= zH@8XRmJ&;P@-Qv?o-QVqq{G{NQ!f#?=Uo2x6Ah8OyLOJaDs&|qE~RoM8$|^t5?UUc zg_RAWQ%qS;4+M()X6MQQqB(|94K+4O1vGZ^^6N==4!s0Cs`;lt<;GiZMd+MhH41T3%xN&+riv1`DfHuv&ZhTZSt z1iPz6V0X11v>&zWsx0$>=pyJs9g>rQM9Rt~XgguCpK|HOaaOmfHQc($(YoH<0`8S6 zgL;d5VwQSRb3~_B?>%|cymfkrIC*T1+{&%(X5N)V3=l-R-`~i2=X_VMYH6#rraNs@ z67l)ym=?LE2u{{NVH)d|Tq+o%pt3$Zo?6?2S9de7N+L>*jvLmt7OK|usHq;ETNd;; zdnt){b+mDVervyjTtaT|glMc8H)SJf~-{pG>|@{6}luFrY9=R5Tn6#9)nV%*kQPOs3%t?d_EEF6%rEhl!*--+e?k&o$D zCw_JD3pm`ky0{DuQdbuVu>9&|t_s~vg>vJLmgo;N>oWL${BI695}HMrk?zc{eFP0z z<9JLvx7PDqd=+acBz_c5J{Fh@2L8ZG*x`YGEoDu=L4(2nBo#At?B0peCIxj8XoMMGJo!~A zVf$yL1OtQOpOq3)1Lfygfj4m@qBVpI%5C=?x`=)v>rT0!J;r02C7!LNi?^soQffc} zgO!=T0tQE3_=iBz@dFai?%~zS*oGw$6YQjeB(z8|C^^>R`6eM2HgxPfz=eOaggk}s zb(48sLFsA+KhxF1FX5rn)eIb;?+)?fXNWIGs0Ok#`l6%naeu}xD!I}5qVKaS@k)HR zLk>jfKm7JkIWV0ClndFEi3E>;cjZoM;LqqqQ4%+4iA6%OhmEis=?vSrCmY6y9wty{ zL^IhV9eqr7k+{I{1Sh3SqEt0Yz0bWk7E^!U?v0FTqj2O)6p>^$UE?iK7 zq-KyAj3DDdvA~!I9b*?5Nxq+tH1DVDd~^M!wv}N1fQ3$BZ-IW+y>f-pN8#pUbpBly zn=KZbbrzfNEjHg;Z01;Ordn*iu-J^S*bLy>mW!#7i*b>Q5tfVDlZ~m6jd78U5tfbF zlZmMSK@l%&@L$&8zO2E1S%dkq2IJ-Nf$e5%eOuZo2V%b>tQ(4zL zcvxqjO0&Gjo_>5Y(u@EwwxU}j#i0!NHdomyz(ZYRB*VKi zg1eWZa%Inxg*XUvdfnSEos{btr@u4{DIV4X1C~4RR~N@YL0ytgX@UL6I8G|4l&-m6 z@-nO|8w2D|uoz_&8G7)oSvC+i2zk3qM(8WAGk-&5z~m6QC2 zdO<@7)xY3{>R%KC=Uvimf2jTi7gYa3AOmEx(c(iMx!|6c`|PxMg~3wnTj|$NP_Qsi zXG8895pc=1T?LtMs=&)SZFKD%@BzjsgTBuRLEVk+HUpvKS=El^Ai|DxlvOvn^pvnnB6>p)WRq<8d?7Puw zT$eCwrTIRrVCz5Cu^T#$m zm*zgJLj+|L?_h(Z;~py9KHvB0SA<5UvpG}oU!kRh;*A)kUgqsqj}sXWASV><>z=wp zN4N2fcQ-cvm8<_|_klvq#V`)rFb-rWhixbaGK9l6gaaAOVH?bW4C1g2l9dv46Bl$7 z7IYI3bmJ3r;}LY@6m+{N=*BGQMo&?d-jGGlKlq z@6@eOva5$ZJvcd{&IKo~uJ*Lxq??ZzV&A!DBf!4ix9T2nFChw*Uw~{@)?vV%tx$IB zI0rr8R^EGnMfchyEmS>~1^`Dcn9>6;yz&e1RlSYZLbV>F7_cZw8wZrU8j4O{#e|Yq z>7eA*_rO;#R|1k-r8vbwlS;{1{qu-hLef@;x?}|4!t+_+q34IPTfal~aFEfnRshQZ zo$^`>rM%8VDX-+{lvkuayn7ruuYUhn6r`Jg(%lz*mT0-cWd`Wnmdn=-a{7T&-YJEu zi5g4ukn0xn%_RfPL!H>V^VvxGB@fL*<5+LfY-ahT?#ykt=3yw;$<5ePu!XG*(jlrW zEVJ~PwU+%Jd1)0!zS${!HI#BM~iADyTq8IjPvIcd0=Ez_$3T6ZmQuZ}7Iv&pJsw z%w%ur*$V|~3<~`xgdQ)DG1m<^6$q7#>|^GKKgA-q3cJoEJQMeEB?=5CY5lYIR69P~ z&-`?JQ%5$xCn2Tfx9@yrE^M9HL;)vlrY)N$)VIe;5%E(?mf`D4r-ok*5};|KO>Tz3 zkOOX)nB4HqlrXiATJQ$}-43>lmy8CCw4Yjj2fOglSI0{xw=VrItS6suv7ego2La9w zHXIGqJJ|7U)NBZrx;bSpnXI~WO&Dn(HP#Ncrk9Kstmh4%ML+eE9|U4M*tLhg#$FBS zbtW1xI~_D=!t4?~Wj1lA4gN>Bwe}~6P13-vi1vMr9&PNY(YrS@BG?-LhQ;SC39Ua<_6~eQ{)Ebim7=hk%4tf=i`@AMize=g?Gl=!q6m~SDW7* zI%#5?Men`UI8bhC9XI7!rr-`3hoXqfa$P)!^2Pm36J)M+aM7B_5|+lHA%?INKs*E> z{k7wM`_=Bd0U-Ug;|s-o;~XrI{(3b{u-+OCgfC$@oqSpI@tRv-bkLx-^#y=28f3P< z04SZ02fM4cD|2S^<9{91U&4gY0FeFA$ax25`Dn;JFauBo!CX2T?rnY9iiPDE-rel~ z^6SXi$w!X{fDG;cko%5H`qA+1xCFo;1P(pN4tj2ZQ2MLM&-B+go3@zZ)`BnkMOKB) z2oinD(W08Bh!naebu4t68HH3YI+*?mI+*@smh-SpoiHYih69~u=C%pa%+w7zq&5VH zgE^hfhgStFjLB;Vll7^}JDt}Ylh3!w)E4f2owV4ey8VO0-RZnvRj|xh(>*lY9BVRj zINzon^xf@_aBp6cMV~5`(|MUOc`aeGe$}!c9Qsb@Q>ud1#^j4^GIfRd^O9)#RFnH5 zFziz`QaBCHa*Q;t$L9KU;6<4qNy3UX5rR}fBMa*>R zt%aSOia%t2Z&rVBw63b4$1u8Y9@LBdg z(-4g74t+fY%k%}XOb-Xk^zB-(Zr=qL2EheY=t2#+uxYcvPBKVTe;dD4!Q_@}(cMo4 zG8%XkpJHSo>-TK&6;fNb!|NGSedPE1=>VV*yQj7lPAS2=^2igKy6?fIEO(+&EYy`E zwsuVEPerAy1rKx7vpkq5&k#&hr#-*?Jz8nl;X+8sa-e@A-JKfpY(u{+y~{D?(nJF3 z0kj&8gn9SD8&}A#lXobQUTg@(x3w1Q{Unh?Rfgkv$IGJbiVUQ8a2vqJyWQyS`^<@UkY@<0;A4u&_YgdR@rf=NTFpYq)3bu4^W^RFjC zj!zhSoUXzL8<^>c_0&S5VTfh3_!xN~)VtUw)2lgtYi%a+^owV!(v_*7`*)waw_gAb zQFK#D;?g(DvzMJ75P07ly`ry7`l{vg*Ya|B#U)`mp~tS`QC2MopSJy~^c^Re}lbL1T!XkqAb-W+;oEmD22$(#L)+d*J6=Bp8hgFkpgV^eIycTaXXttft zbNifD(7z_sN5jA!+JfwBLrP}vqS{S(;u>_g{XAY1u4P|yecnDP!|kW|nve;cM7K{~ z(!zO6$?Z38Ba7XmixaMeQ-}tu*MwjU>sRP8;?QH%YT@kNp_NcFTW5)D$kM`z1SiU7 z>lEC6PXDh1sDc4h3-*MGGfX-58*Z;-!+qsw=Yy{1JmbIeL>>PwgA9nwQ5Ac7o8|nC zJ1pmgxdQ`&vCd|wu;3_1%Rp0dn(3wnzLspvEl^jJ+MRf9Wdzs(XLO773Wb|J^# zCRoWHDr_i-E^N51^z`=V57Y7D3s2>_VuJD>`#GGyK(-}Yp~R-_dncXZW$f7ukX0Rm zYkvO4Fcw{g%Ee6iHgxW_eHt4V_N@%%OCaU?Y=&$4mtd&<_QgypV)?UCL2elaY|(5o zmo(0)-hy)I@S10bu^jO!WD{ixzp{Zz7IZJefQ6g_DhQ?es~}Y0J*>1E1(sO+rmKq6 z7oC*kZxf7>M@{32Jyo;#if?*0aWU#_;s^eiJQt$7_-wNA@?fNH4Ean&YrZ@(q1?EWlE&9W@UUBqdS{UCK@XJdIXemt^WdHO-^b7$Af6=m(lM+3Y zh1hC}1CkQ5zoY~|FKLRuXbwq`AFn;l6LS`l&zPHbfvgtb_fo$29FOg6@Z!e9GLK+d ztRLwrj5uSopxsAe^gbTlQw58!P`mU6_hXt>lLt6Y#TM@b$^_zob`}yB8efHUvX_ET z`|}_ssZ81?=K90+jU^QQeLvcF4TM7`IM!D&g%U96JA8=DKjNG(W|axRq9)f;y2>i^ z42y(ZQ0X0ujBf%aM~<{F1_y^v@XSQhlE?H$gV2GAxDJgd0g)cYpM*p91-s4 zachGgjyJK|P6r9we@qe??}R6lokTtOx|*(d_PGxenepATRmsx0Js3n{K7=fopQRtX zS>f8SjT7siYRn>851qCt*YIW0z9JeKHA~m*3LIYXvzC7OHSHRV~-5aDY!g6*lmhrE&p$#;C9~Rn<>$l0c}zeh}(c z76|n|8uc<7l>&`Qjz%R#qY|T037e|+nmDo1cYO+>UPGgjp;58WsAnM5^N8ZL!^vl` zf@(>zUh3ty>T2uFRU#V?_}&-oRc|~@{v6O2Kxy767dLNcFLG9K%@Hd^nv5%YQA+w| zIvz!(k&7V841-%H5R0DNRLPDt=PZH7!X#hKnd_fZIuQ4QWJyV%kv&R3m*l!?4ADLzn5&rRff3GsQGwBGTb zx4sQ#ob_!?`qGarZ14DSt#4z{3w&(BdY4u~&K`=c2)8=??4)^tOXFPZG;Q23!Q-C3 zGNY;iIB-2|gw)AFkE(zSTmF7B0~cm{x(qET&NGbrN(6F&G_{qV;uyFvZmo0Qx~k-d zBWouO-ZD?N^Hy1v?QL0tte?5`U!dg2VJ>q%COufRr-?%8YI-n!PtyiqnTe*} ziKd2$rs9dFjESbGiKeG%K}Q_KM;sA{9K?W$4mgMpI3o5ri1#@n_Be?5lOAZ750l2_OqO4>%(X2!W-+tv+BbA>cSt^ zh0E22U#ttqtP7vHLALgoVf8V?%43G*#|%FnGb}x3SbWT|@R(u#F~eLii|q`J?F^~y z44&=G8QbcO8%oxmVH0#K%%KiAZa4>=G_x^mCa>VH5ZO_wPg9>7A4wzFKhiHa$`a-A zzrd_5Uckb7$|8(^R%#OWSgD(@hh!f^N@1P}nOuj-p5Amd+a2C|E(n7^y2*!n{j9Nd zFM%rtpH1hLIuWmh4u7mmRNIB-^e2F>C{es&}9`Gh4oZ~R}4GuPWz?6`H z1Bl>@#WC*_d^@*bFL@$v>q4uTFo46hQOf)G_YK@4SSa!DSxDM!zM^=7)pM5?~X zE_v70!`^gEzq923K}Q6clOi}e86}VVargb#MP>E{>`iMb@)?C5dw2&tqTATj%t=J9 zK(cdJd}|$6Z-0{F1SIc=gD#QdLEBMpI6V-+;|Mq%I7oWJX`zERoCZ2nj$WYI`|ha^ zMUC<>~MJA?1r$EBsunKqU)N;q6LwJQJCOJzA1Rb@Z2*58ruwc1~|`)I`r03n4O>{zIjIZ_DgWogD3WcHrdH ztI$ujP1xt^i}d$Z|IH{2dqN}Top9-V@UlG3F}G_1PlDx)>C&Uo(vjF|)>MU>6IP_2 z_;$J405RNHT(FNk@gjH9MdIcJ(<8;} znwKJUnO<|6ms^xvQx->>XNpTA==bpnA6J)7hZ8tHoq`1ib$|OyR-^0(u zYOJCn$~GEkFkutE8cna)MpQ71Q;vr4SsVa`Xz*ww+Kr}XU=tQmvayRDouqNVjK8=) zI>%Ni!w$jIsL_u~HYV)C@1p7Z&>$F151KIErmV5gYEH^87I^li@w*_^N=EWW&EFG6l+>ivuHIFXMqKlP z$Gxp9&0zcHsxWg8n9kww|3ZV4wwpSk z^Lx|5!UgN-EWNIOJ$z)knjckOq##sBH@yGIbU8n&ut;G|?z#i>o2WpIaEWJ+X89>D zMrKgCoy-0lqjiDjwY<)qU_msL-3bOzkWGG1g}o%|mg&W~&pO;ug<2Q(?gWpjuy3-& zeU{6UuR51q6w4&X{#BdHD|?$Q?(;3~s5q?);b;Jz0a(43AGi~2{fc~8iM=H5mMKr% z=UVhA5=!iwq})+&WtVueTQ!28P~L)Fx}nTo5`D{*Jx=K&8hGNAK!1JisB*0f^snWG zz(CpL!?)NS_~JgFTt!$ouaakf=Ary()hxHPnNi#{nqOvK)Soj!`uUtq;6anG;dRN} ztCG3z(2(b)rg@Z{xgmOU#xX=_mg4c}OS`POLxIWDqz)l+pD#tQ=86O)PgC3pi7};! zLxaM#a~Em-a8lmbn(i#udSuWtZsR?Wz{7 zsf7lbHm)#J3Y}}`cxZ24LBmDbn*hKm4{fvYwUAm<3fwj>;%H3<_AHTruuo=Gk~5;p z3YuuR&z5yHT2rr$tH6|^91Y>76aWfMDOOpsT(eA68}zjss*1ka#^ztrz5BNAf3)xk z?Yy8pEfcZc%v<=yiQThUE?=$Yglu6brQe0|o%nK1b!nYyly{E*Z2~EnxxR>=c8bs$ z0sgRrk4@{^oB{lDpw6jmi~=a#k44@)(`vDRA%NE>6E8-nqZ5TYi{bX6kyP+(c+V@S z{i*!+KL3c9^wCo_2}816lu6quCLL+)^lG=BBJNp6yizBY<1s2`5?J%0{YlY`-4dr8 zB@a_`MyY5lUgu;FBEOILiEcJ-{RPR~jnh?iGn?#(Tf>hh8c1)`kB`p{?orHsLyUb8 zecpX|QjoV>nmN)PLMO%Z=(r$nr!;e*J7m{er);k@(=UyZ@wi}d5q?uqibw3=UT<4> z$mnrvw>WnqH7y$MB~ks-b)>!)|B%%$8A1=VM4IjVh zCv7#06!SNo{$B@B1p}y7aQ}En;x-s0u3e=BfX?*^bw|rSldO(s(PO_dQ%v4MBnH1!_d4snQhAHjK#=b z=$`Y3=j<;lbnKK4m1VIe3o*1wI-U?!!OB{?tzoQceW{5^c=5&50EZDf!+CgDz06VQ zqxzdiJ5$dt+$%${u2xvo%Q9G@xMq61%MelSQX@sAoIiRj5LDvRmRz|+t?Y<0gx@Z8 zpLZ;bHDViYtouQXcYw{vy2eiLG0{udovkJ0-Jpm3ne}|3s^WB?EE}U%zD-of>=FF% zuC*fd_7eGekr|f@b+(;Zf@rR6Dr0-X1bX`oU;0VsTj(*AqC6SWPY5g!>w>Z00s==6 ze)bkpBWbXs37ThpQyFx%83zOwr}XYcB(}NyM1_jWTUICHn9s!|v@%@EyfF$9ipx7w ztAaThI~HEvh3YA4bvV&J0>sjol(*8N4E1@^#yDyS`+;SG?s9VWx@VIyb42@>yc6H zJGb#JIdVK}@5}ND43R026)EI7kX|pWwrw1!FPYEiN)uw)`2C1b?tAa9*ajHAWV3sv38fVPWdj;EKMo4#p)sgj*0io#jtGeE)z zib!+YdpeFvhxm2n#2$-iZo=2c>UG4fb(;RZG_)xd>^6@ke(fXwHv6;0J{;pSI3K|IAeTo zj<%04HR0dLT;L03+<>U}a4C1e)^9hy@6>&e<@C_*va%$p28z8;>I24C+ts9M4f|yfiI<6 zu7g(r!K9HBw7#G%XuS7`efyLVkS5UmPn&34 zLwkiS>fU2MLGa(-IEKlred1nWlO3gXTfLS-yVi{ ze*^rgv3DtVo?-6wow+@}wUo|UdF0tO%84}^S4Uz(@dv{7ej7;ZQ+Dt8b)?%@GcM<) z#$dXzjFCA1$Cm1HqK`#*UBa(LxKr=Ey*W@RGNj9@#zoF~Wd4is3r><(t7VQ<-a28g z^4*ZF3sLREx}u$rEfMAicf3kg6XfUTLhI!iK_qYEjhY@G9#z@qoiyIKQj2pB7iZuR zwcXXzl+OAlB>5>(*G{hf%=ckWaRz$c+<<4 z;l$w8WGYg_`9owRGn2y%x3T!9O^`+reFK4k7il;j!SCN&G0TI*Ab0H`#b2185~3FMEk_@9?*_ ze=2ndnm3J-Puz9 z3KFn2DILP|+8y~0MMkS4w{}orY zg*KW|PRDZDS6Ng2X4teXGvP%$60MdR?fWAub*OT(j|s=hrt)gq z4MAF3aH++xfDU^d(`vhMapFo(^K)Qxs7=xwM%2OIW*;ujTr~~OT2Xaje%PQF-3;a=crx}*$>ieGl_=zp$8ul89Ae!;c}m3gQh3`DC1dE6h-+MHGe ziPrp+juSu%HvYZt2d#!gOJ!5fjs^B6(oz0asE$+0Y15l84}jMEVP%m^l-rK#J0moE z#^3P_ae!`6OjT3c`n{FBqKp)w8G>vTA-4x~^Iq#v01%Wa7N_EV&&3$5dc|MX2hG<*((%>7Lu3lZ*GMS?2>tTiD*7i*ooIX5jF)<^ve;jW?*G?k!#D1 z!Jh=G>ciIRvyRT$8%`_k^`2y2_kIFnR-;JkJu!O%UaO}YG;>X=Dsqjl=m;^~0^^h< z=!H2Wy9;;V)NP522(QLa*oqy<7s*c1t;d_I^IT#E)|5DKX(Y~10_Py1h+zenqh5j;zXjkEDK$o%w zR|2yBRF<=8l_-E{cm&@CW)jcW4nUxvq|-jl#eqndjM*~_nw)}dP?w$i27AEFnme(~=Q&=5*-c z56}Eo=d7r03>#>k!jN?2XS@KCB>CqvRBdN`q1nZddq!AKkr++jo)vuusDldVfI-!U z@w3Ci?+)_B>n+l+h+AK72ki1?p4ct|Rk(CYgMLFIekTG>dMEJV6?a8Q1-b|V>r)UB z_83xv&*mM&iX<7V$a432vkn-h^GOw7cGK2bc=wJ-W)_ifhIHkfUVDQISm9~1cVh-- zPUyg1FEkNc753tLPh6gWiJ)?fo(L`Ii7<_x2#5@5BFsY*Va^GKbR(GfiaC=%v~>ox zS0xNzQgo*je{v-?rL(kY&$OPgk$^Vh2gO&*ycsV4TJOTmS zdQ>gp2XrHrjjyi_aV_WhY2q4KFovD?qnv)lYj1A%o1zY9x`@V~W5ya0%*f#;wt9$F z#&7cTrgk>VZ^-gW9>r^lAn|0jd8h6(NF@0MPu^tk+~B=|pBRWc;7D!H&y?EP*tC9) zNwRt{EhF3ozGWjJYp8aK@5H+3fudJfDBO`>v*vkd_i3Ettcp~B{!kN*z38Q??b6y1 z#+^U6p+Y&lsE}lce3(3!;%|9LN>2E($XCIx%^c=jQ>iX-e5)4z(-iCL75_-t{TEqO z+f%N`)35w5-&R2zEm5iVU1uE&qaCkw-PH*??=Pi=pzU9fFbfyqEzUez^zNlwrq+HF z)>xCAq<`38+?>N0hJbJJZB#!)bUS*_8y?zap81^2LogVPwiyi{nRPWM=Qkz3x3+qI z-xUR3I_oG#Ro^wQJAJ(xCfWwHtl44m!=%Wc&+954_qZcBLEX%_aT?2@P=xAYS5fCL z^ONl;*{B*?U`TQf0*gs>=Wl(n|6=TZDKX(ne&t^p(Curpa``#?Oq@p1a<`!uyO1iF zaiE6x+2pxU8ZAse(+A9_l&qfA9N|jWZrND8>nOAeM1JK!b6eRxMR&Dr!(MF)BL|0M|NMW>v~gS!~{J4wvG0G+D7jG$u_#D^T#%NUGkT0 zl+2Z6>$4!ywX)V+UFsG;)QKFs+6a%xCQ;0moY%YO`od1Y6fDHpwdeIZibIlFzu-O) z2wO!Qu-!NAo*o)zP-)_w)FY1W4?22%8WCe!YJX+v*P15WjdJVFsFkibag27zdG{vE zl6xyZMXHL_LYqy`Y4k|<(~^6*?p?En9~<^vgiz%5D*JmYh6ClB5kv)4m;d65L@)by z1+vN9t#&2WOm*St1w`;yYWNqMJg+#Ty=l99{vzzRl6e8ie(J%K1()#h0r4B}KE#uWEU!zi@J^Z>izgw1C)kfYoOw@h-CA*UY~$De(1r@> zFtk$B6&`@w^~3OUv#YBR$@#`Fu6m9KCi`-dX7KtxQD2>l5$$h)xP_IxZD%c`ZFN=K>_Eas#gjaO$FWCw z?t0DZgB8lo!?$t2Ih?!b+Teq?+S8ZyB}=d8*D@uxFBo2{rt0pRzxTkItlNR5P+|1T zKA-)^QSLNZLiA#M^+^kV{R8hfw<{_ap37N6mW4g{|prve9(x z$Umwv`EE7Pn$=V-GUY&8svQ`%w|;OHqCVeDP`SSXQ<$o`h}B#Dm$}?rz0GFI#H814 z)bxiu`zyvm(g}mr8+Z-5?f)un{j3&tY$O!yek|OP1T};z6S#~&H&4Tei~0j+?8ClU zm0rCv2YF)@U$z{SZ_mW8v`(G*p8QZE*T?*C?sn+%1@aV@T>AX?ul-e^>z>J5ZHKqb zGVg(8Sr7cdmvzWsmQU8ouJeR>j8FgJ+|}>NjS>q_|DJQHTLKGT1J7ei&l}$R@Zt%y z{+qeO%+Clmf}S&Gi1Ksr2my{;TH1{ z+1^#R{tMZ<%FtvJc>EXH65szM+if)2eE*efeLu-o_8-WW_z&5VE&nDP7^qPK?)%>( z8+KP&w!b!W9Rsn-!XveCluF|p*_ztME87e=x((#KW>!q&K8RO%&Wz697Ml9C-u>ys zx&deBX_BLzPM*CiGzUozTTTZeP@k@J`9|)iOHG)J(-I#p|2vMOhrcVAT*qqZ(4ROD z$SacmqI<=dHR4T22eNeNRayqLs$CFhok%~xzMdv9PC2ayrJ3_KJyTe9Tj{CHKt5e$Bdz-Jw)`(8IaaC&^Z6h^(S=EEE`l zyv0cq)%QcpxE?JvYL+)^^tXR1i~UJutMHQWDk`T!?15qteqGjxvLFG+-&3H^v#WCq zgzFBJ_|C^O(ZiY*`lVF-xvT#%`?juR+0N)}IY3?5zS+DXk0WSM#XQOw$T zZ+dLFMrCDw@2z8@6dxT>B*Uk9cB0|c+m5v%s)y8jUGv77E*N`a6YZi)*=dX5zcKuf z9AtP{Y23_l66yhWIuaYU_P?$eC|tv3V(e2jri#r6Mt8Y z4!OCle2E2YtETVD5^@W@2P@aV@x4(`3~&}@F58x?4GB*PwS{k8u}}J5VI$d{e2bZh zVkhCQ*_7U_X%NJ08)2f9j&H)??=#mA*XKyJ%5LPoN8RkFoL*(L$yiu)8>d^MUck<8 z8WWuZM|cT7pWJmYrNb@3o6XZ;%c6XGtW52spr!avm?e0Jd72SYR9TgkX_0gx&#d_0 za1y^m9RI*3t@+PpdB)!2$=PyG^SyKST4v_nY2b&0TpagB(?m}}9CqG8a?D#&Mg1nx zrF+(2yL(jWnI1_lyaG(>>*NLbCAqsSys4751)czlE!#^F;WtnH&65Jg%EU$H4hH+n z^9`Kixwh)iGkbab`*b`4?%Mssb?IQhpZmj<|H7XuFDF*?!TOKM0`Rt=RQ3G7@V3F$ z1dUJMR2^|`#?Em0DN)K`V8va%fR?O{%Il{o4T_9w%iZF1X+|>>y{=xa;{Ik95_D+> zGossS%xlXeoD*|{t`YTjgMQ%*TkQmag*+Eq*5-lsDN&+sP(_SuKv&k*@bbMW$nDS49)h@b$3*A8QPs72JQ$BVN|NR0<#Oncg@ePzL-(y$smKqDOm#Hpmr}M;y zlUbXGb}kPt$@qL)NU2X7`xU-`rignt&WCgMujE&Jl73MnW407`4NxTafWfGUlq5SS zX8GTQurxAphNmftoWJ$AJk{7toB^bYcJeYm0Bc)2^He~2MxrU;!Yb=FMEI@6_jyGW z=>|O%oyI!4EVK%l(TY{wqPz4@>P^F$AqNOp8~?%Sh+MPnIdQ0p`~jvBzwFk3x&PAK z-Jpx?nejk6|CID?x$(9j8voldpzq<~x<;5MP5R-1wv-68PxHOaQw}V)kE;NEf!~Fx zJ&FYLiB$a>F0|F)DxL`KJf#`!P0#>;`%{YAjJ<=MQ=&pZ-(MtgI!&2UWMoq65f@8? zEll*f0s02R7bV2fj21*Mt1~kxk#f#oN#9~f$|VKtMwp_wur;_!=I-UHcUNJFTEkuK zbAJ#JmjMG=I|o*K7PXQR1w2_h1QsXa`bDI_H+u$=y%2_h!ZLNwAzzs>>$uuOI{nCj zg>Q%T-U={x2~SE7ra{!LdE-Mj0yEZg_Yx#91t-!(jNL6fDa9G4=M1O5M(%J6&HZJ> zkMS>>Gf+Cq+c^K@EKjteJqOmjhOYctA4=?gE{PP`-)h!r&SbWfH&sz_t^vP4gZ;eC zZ@>T8!srY9g5yWpeT7p`rZGtdNm|7)c-segFR zA>v#?$6t%jow}VswV9D&Lvb1!UbuU__dDHU%RgRc7}8MGws!j>@DLCa#XH8SNDbu= zmHqJ!7di66jh7q!ra*=CQoG9z*W`f?i*Z$8Ch`&-KC&2BR(B*?Mb75j`$wF16*Cy5 zlaK^lQM>Z_Q}O3EQb@5)(>ij`YYi`GC5so3k}SJ(ot(YZUD-&t;Y|0f$GuDvaT0qs zq$GST`84`_wTO$*0(s?d$};C}N8$F=eXqz$ZK@Z|#sQCjpr`wmV8CC|?z+pvT|^4& zx^r`)bSM>(5ie9z+sZ4*sM>A7cQQSCKjnjX`SJAV)abbhCuqT1alSGDIR6P2Z!8c) zY-qn`_ggSVg9o7(tWTbIBu|o+h`rEt|I35B=*5@wg~1+=ZEuWPctjDY;;kkIsXwd( zkEoZ~QW@AuoCAKWhD0|YX3_gKSzmwduin`cwKZammKq)`s>Ex0bz2t$=IIl}k~Qum^B5GXo@CR!yNzLT~3W#6!G0fw*_J z1I8BykA%yNnISTXMRvgl4_pG6om^RDkc*z)DG0~_T4hVk*jn^-PFZ*-;RRZf6DoYV z9IaFT7*MbZ#l@Ye`>M3rFi;xyxx4>wU0ClNIk4Q=SanUm-e;gbYvU|5M`+1_wATtNlFmL?(k1w;mSkG{9(q$?RqK7mfyF5~uqJ1q z{qPl`)L*hzX?NJx({GKs&&zLRxiN~4RtrJaFC0`SD?xFh`5Va)5Ue?<@;AZ2rrcXV zu+V}1#8sZA;1PkXliwSyUyji`w3^Vyxn!~iTj(y|s}rhKAjMai&ComBcaVxll+*Hz zbYR0&5xvg-FpKu)`i?|yf~m=rar9f6zXASKFv}iEo_IkIy}f5v{Bx%_+UxL0Xwh3{ ztjLAvQxS=x`|Qk_Ihgc;ALOByh&`nblRN4?#V!M(tKcyhE=5OTmLV`!NuYiHb&Vt2 ztHi5{M_X1Xdf>K~(8>}PL|}9xulq2A0?gR#MZ$}L9rSBkt^o91-ep>m-H{X(w zXa|*kj_+~rx&U! z#pVybUEX=nd@Z+MI9(JbFZdOePI`X*jXXMCIho41ps#M4xf=|ArHV1wh{N8f2iPTnj+3@@ zSG;^dm)Q_m4!-i>vk=l#q5QbQJ*9#%QF2!{wpbUkS40C>yn!@Me7HHhj^3!#-jaI< z-!hjX?VyDv5s)Gmjp^n%|>|y@Ug69Lu_5LNHX{-kC@)^#_98x-2fVxVx@*>5pAWFC-KkwHpjeKMG%Xzk9Ivm;Flhp#AW`L z$%LQa?-lgkRj2Z{a({cH!?3mFjh59fflRuvGB5Nsd6Sat5cftQezxg@3(pa51Nw)D z9(6`@ef+oAgQw52+M6m*5{`A7o0jDhGRJeV87*%IT0SIvmn#fuQa*gW+s(JCJ6uPo zwLJd>5Lh4=y#AM5@VhNoE|{RIX&>c;g+~>yO1+ry&!i#NjLCi zkCmRWUl@a&|DOzfgA2c!4q(Ecq~xdmg$X}>`lGaKR)0?^Ci$78H=|_V+FzD(--i)A zpYz$dGwWeX!-SFIn zXA8IPq=C%zxVL=&TmEndIqUD_Wm!%)c^JQDG`I1Im{nl;h3L9=%2*|zGfxL@IXd4f zKjXXeUT>Qg=q9WlD+>IYbQ_QW z^hFvs|6ha$!h#7-#q~xAg-D8j{>b!A^~rA)0=Wxk%B|NyHngy>O4fecL!6TtCPKG1O%Oi|2;Hbd z=lf$0mX@k`B|cOBVq}W`&tFAb9XXF+sYCX+7nK4;_J5Ezgh%#sQ1bXX%ICGeB#-$% zBuJVad^5kXFg)=G7cRW;RqNCm?Qq(5+o~NdZBNjlj%e%ik}eQ>xcEKgXB7uzJI7~* z&OgX@uFncjA~b9x+Tg0dQes1Lhe*{UB4Y$7R#;$)l|p-zXYHJ6u|j)ie=N+q)zfQU z0e#Cw;!_g??QUrK7|~tWTb=kco-gc`u#v|6+F;2#!Rsz8U5qX;Z$OO5-1_0Zr2RHh z1WR%>*uAn(5fG|L%Lfntkx+G@u7Eg6C8^JU5ULIgyD&mE?wDZSpFwrycjS9?UH~4T zfXD3r3Rrb{TnE64{^r{qu0X#2!(snA=+Vqcx-u)zZVYsuw0(Q7jQIp)7x|Fqo;(lW zD^N_qNNi4>K9%2i0k1v=*9nI|Z|syzP8~*ZaJTA9-~&at#cO2tK3V+NNPHwx zROlfc)6eJof$SO3RB3Iz!B&AjgQt(ydSW3BpyH#vPp`o;+#t%L`haLoPlalHEzJ1Z zCn$3r@xX_yh!&X|`4JtmxicF-Fc<&^i`T*ye;GLZHn@rW+=v?RrT5(=&xi&udBJ)r z!toEjw22#~prxF!A^Ri@5b5BtDGTIGJa?%2^dg?^{W z{2A3Cpr)nGAlA)W@{nNuLw)3C_L=nB8Q^JCn1r&=dVX9A)|TGrp!b61n-^pOVK22q zGOaIj)HL83z{kFq4WwebwO3T{cE&>bCHATQCeQ!xAkRgY**p}nUzQs7Bb!FTffKc4)q_hI1m4oR^pd! z+VzU%QrwYea|G16e4u_fRTFVY!yVi_W;;UUKwMKh?;g-#*ox`@(en!cJY>#>ALDEPnB* z@MVG^%Y?i9<+lb7s15J`R2$lHJsXWq!xR1o_WOT2SxUe&Up@d+rMbn=CV$3WKNo&i zXT4c0S!AX4zmW3d?g@Ax$bLg;BZb^=>B_fy8`4B)=wM8a?baCu$J1Ecb-} zKQhrN@gU7?66_H3k1R-k$x#a0n;Y1U!FzKR|IA+ZZh*7~2Iu>K%D%n;f*JP!zPDW5 zO~09&vXp*uh)V+$>hp)ev~2SpN52!ZcheoFdCk2()q?!T4Os%SJHJ!LEg;VUl6hek zBB3BN7KhT%Z;1ChqYY)in?}F92cOI&xUu1%8Gldkri_Q@^9(5wG?nx9P^!OVG`*br zj;46HQ7l>z*mhNYmdwV^=b!}fuh)kho{GHwzSiPNVc2nguHFCc1Y}>)dce-pBJbOq zxR3K&JTF{j7b>5g3z9-F(3D|>%Pu%P6_WkB3VOadPMwqXe|qUPac`gm%pP)^v7<=S=ceqxbo9YGkW8Qs@610t(m!8yRL{gyVnDA- z99;Q}ydH|&V|llxSugPVVaQ049wg!HKDFg7#pe9D&YXVJ@i$k=>1}u!_g-l=E3!cr z`hArjnG?RY|4WL0;$SA7SkLV-;Ae+tL28 zT=k$|Ewg*`4-wXyM^FB18+B?+hrep_R%kl;=*qBOPydlPS$n+JAJ$%3>H1ET<+0KN z`^Do@!`REVhRT|RAG#kKKEJnDa$8{p`c`5hcE+0tUL_C9<^Ld-W^88dHLC#`UdLA` z@E0=tM?$7PgG&a+D|sO!rM487g`{GpdJzwPM1p7i1shl5f79px=g{Y( zaq9&0m8a)HmY#%DdmQ^if$xvT1M;$0T$eX(Ha{YXu#{rEFuuY?Wb&9fIh*)RuR{6# zj3X-_APZM$#rp7@=}-`HpR)$F-;(D8| z2(2-*S0K-UWVUqjJMXJ-)_VZ*zVg${$8G_9uV|IZ{&+X-EX4>gH;SXjgHR4cBpYxo zKXb+1Ki^t=bCwTLKeW(u`>z@%aDP3K06w*wZYLGLG*odOZYMnEUi^I^Jp`2P*lnFb zaBtJ~5B#!!y#@plFa4!w;AJ+DddVa|xh)1!a<-7F?|tk^AV}9tI9-L)$N`dkkjyPz ze`|ICaM^#5U<|Q%jsZk-mKB$d?!}R2BPYj zFl{QSV(hF@S=BWol{K4@L(7c~hWvLA*A#{)gSE+2pR!s$lP-R$x~4r`i&JeaRji}B zraA1!0Xd5VL(Y*|qa7Kevu`&>Ca3PJJSzpat;VV5$r{xho($CW|+lb)#>vGa|D@E)1XlPxe z@S-m5rn(=8s!z9BajiZ~VE3n7U=+N84depPe#@+YTwvPkZ@Iw#6S;r~h>aTN>q47O z=1Y~6e_g2QX9Px$18IOONwvPj#%vTM4QPi+1Ds&e0EM5@fCxw$p!V}M{O_>W@J(T_ z;d8)V!`}n1;d{9@Ty>=XAn%xVx#r<~>8U@}|G8;v?X+@l>#X)<{rs%aT2%0=vGgcC z)q8d<2-dk^wmf@uuu{2avw%=})i%9{J$5p`S%bXpWq0&d(z)q_`=)rE{#W6nvT2UZ zH21kpBA0$)$D^>iWy<=qwrL0K*^7!DxUW~h=gk)Ism~UKtoLEor!Z?z$U3bNvR0nG z_-*+0i%XN0N5&C!hZWczU_RK%pP@Va*FHbZdD3oNa1eQ3n(bFPjKc{&k&T~`L9-Xb zs$LZ1r$$~(6vN_O&i#>zd8DY1dwrPLVT`yRdc$hlnQJzmTg|Muq2vcblpC!pr|XW{ zW7QQ0{|VY#FX&yg;N_`N=}6)pso=`N%jb>IV1B{*0VixtuYDc!1zpsli2NK1`3u_Y zSWss^;$t*;uVYjOR2w_4Pcl;-^rbH|MpFd-FX$G&;KU)uh{fm#PYPg{wkT6as12|9q^plV#6$^RoVs(vxF-uTxR?3UpgjeV4Kg&HC3L_= zffpCCq1U-i@q%H%nDqV=$b?t>{Q&MGctz`8`NU{3>>oR>tRoVV-~%Ly;ex7ubDck| zKs9_?+r`nx{{7W0*vC7r-2L-kg3AzJ-7|nbW|XmqfNzW#uAIG*h}sq@1KkZo->(YQ zLh=JR=J5A7zaYN)i2I03fL>e?+^>e8(ZZPx_DQVib<*g5pxk-EaAX1g7f^4Jq{e2@ zgJHiW$JW!(L?PI}WYo6#fsFs+rVA6iNfG)H>S$l0Hb=pDL6hwe^?pZQ z?(P%W{~X4$zT_Ic;VgMF1l-x7A*yZl`G(r+oUCsX@ilru_1d?II2!kYS(YRTzGQ|@ zsI(d98?vi&61+`BMZKxciTyV5x<;=r3xha;Lq;gGN*hMLA-uZX`Ru*S8Cb#04?Q@J z@Tmhic%6t`gS1Foc9q$o-!Z_Sp!Gpm2DL3>#MkdA;D1}ixT*k+06IHT?zV-tClRZ^ z{jC0cLqTI0-&YD$ooUtmr!rNo_vX{R!>2fp7QS2&4Z^BcqJML6o||>!Wr%1x`6hD6 zIpuPDamfFDY>i1HHwLIwIkmOk3@WM}xR`!x@>*CDEQAWHou#UR!fMaKw&vh;yqzi! zosLtbq0{1S(37t=g^yQ3{WG!z9#H3OG#3M^r8WeLqt)6K_(HYRpb}{_b@)*Iv=94Y zP%X7#=vY%F2GvqSg$kk#!9lgu)IoEJE-9>*8WL1Xjq%EG`d~)B3DiQftpK&qs9+`1 z7@-nrb@RD;MRhz%OKr7J*XY1MOH%7W`Lys@XK-Vu3ieUmt<)UQfXuiI#u${Z0b|&6 zvA-j7y3#CQ+ZGi%z1GCEdH;kSO>HlAX!3adrveZpc>0ceKR$1JueVeD@O+ZhYlEO^ zCv^6Cn@z(!Xgh)dTW<#-5(Z_x9e~t#?)QtO_QK5@ar)k8ooL=^BJ3-b-Xj}4m$}nK z&}SpP2e!0zA3O)U+KS(~VoLVL?-LDKO7~rwVli)g|2kts5Ar2|e5=j9*pg?1mw2;I zip{-PlbeY8z>c_7QhV50C$fX*+2)t>cdqd7G?n-+x!0jiZr%m9I)fgp$@*bSV_7HR z=3cbPv!P31Byhh5*!{ppy5N4HOX*U3%Hn&kSM`pSVIfs{$DOJ2IOQfsFY+0qKh4cCL4}|kYzD(sqGYXR2_``|y z;N{FLO>#42QPZp)5?_D=2of9I{*z`X;r%yA(`l+iB+Weo%Z^BzXUtHL(`m>(0&Ou! znmLV8-b7KS(23^5a65*IxC^^z5m|HBPa6iAT|WSD3DB^J?B0cq6+=Z%C(5VbWs7n0 zq6g38(mv)q1BQ=sUQg&m%VMY=bzxh=K-z^3pbf)e4AnZlD4(2{ZPfW3)5#~!MPzp6 z?UNq)T|Wf~2(%|JqR&4ncs-#P&4XT36yMEb=$Q`ZSIiAKA z_Lx%e{kMtRSTPUF-7GCUJ$VG@?eam1AaoLJZfu}FGaI@}JJqL+%3LO}%MtgBHaox2 z4+;e9{8N%-i%*gP>AhTz6uRk(V=fQ;Q}c+E4Mp^;nHg}uO;_0wtBIlM=J?>*N^pW= z%zSW+?Si3ey0OXk9=qDTMy8_l^hrmQ<@fczdO$nBkMc-X*SgrbbwNc5oidM_`}XJK zT?%)_Lc42ZD}9F(9!3%^6ayvvJ5;^;TG~w{zfy55t(WH9D|_c z0TXdrj@~2rhO!v9%xD5uwO0eehtbIjh~BAjSmo+{NO1e6w;F(4Ktw6g zFffASDZEF#8c-7PV=alXfJjq~qbNtu{3mkt%yab~DK?b7ax}=FDInVX zIg0pdK#&TDqmz_=zfhoCW+CmV+mifhK>RQ|YXK1{4B7=m0Ha{gT)lC*hO%fk1J;9P z&D8*RFbZwBjq?UucvJiI2KfF(q`@1wEIH%}{RDTAy@w^gRhj9>56 zTGyB8l&+1gxotQ#9M;Y}*R`oHc`rUTm9cgPLr}&VKnDzOsMi=(4;0iJa5Z?dR%O(u zL*MGC9%!pK5Ng;+jgYAxXsS05Xv~Ja-I5-`&RRuQJ;=^K<;<^r;F9i?A~nJa`A!GF zB~x``eQPZ}@)YKa1NnksG}S#h-Zm0xhz7r0<~}p_|#VKq4IXP_Ga14Fp3gRSZxT)w-Xfaok*$p3)Rkf8DP3$x$=W+3VHT zsr2%QhWis!cRFVBY!-I)b(=YIT167h>hsz~7*C<&`(tq2tbI*dw`Og*UQ$<3UbhJ~ zB#<(48F`N=zq}~+(p$GV_+sc?m`-q}bCEMXySm(ZsVPc-`2LinylF%^81JO4Y4uGD zXd?q{U1d!p{Q20Z3g&94ph~zHUEU#+$F!~;7lK+M9CNP^ zzNr`*H+29>R5OO0!A&(fzUT}oUmR2ky5pz}NncDJ-X&GoQJw{$0d)K|}tn2t(mhc^@47h6@{;rQ!rI6RFY>w^oOwr!Qd%N)`3Rr(VAU)lhTu5XR$DtQD6Fw1{1AY9qNI^)l~Q}PB9Em3us5x zWUX={#^or=;{^;^omv})agNkvh2$u9sGVA~hjAjog*?R${%Y_$G$$z=-b}q8Yr!(B z!J05s595F_cz%wd0F5!Pw;JqTKuehu@jOakUUfBCwtzMbT%b9%*8aa8AP)?}kb71a zw;fC59YgfAFU+WTCRf%1Orf91N793UDi&ibNUH!ZPu&X+vO zD1{uv#*g9VLocj9Vt$BDembCt$uTD_ke>Ab%lTu3&bkjdnE1AS!Hh$&7mF}1jnAAw z^A(GldPWy`*B(r#^9B%Kf$6k;_B0x7TECRi%EkDC`o^Mjg~=c^-~Mf2q~r@TtmNn! zN<`wMmZ?2xt!Ts&&gfus`-lamnz+SU=E&rVcO!MfQR5*JS14I)=NM zA8-+Fiun`KOT=-xa^>v935X#VJNjUjiPMk`Tpzzi7UK|TIyRHc{TLMvj{0NR4Qho5 zAyn%XxH~@Awau@gKY4Kz?0;2ujnI*KyL}Y;LA+#Cuvzchd zOe7#!iiP7?e#8LJqd*7DI|!y9Uz$hkNQZ#cT*Qw5Y8WZOUsnXlu$%qRTRaWPud7Fr>aW9C)RFWVzGqgsf zO+DX`fi4&nRn9jgRp&&1n~12<`+_A;jDR~M6jh~d$D2FAP4XsK1hpTO5B9+D_>4z~lJ_$5=ikzJY1Se(oew6l$ zcip+fPzm{!0H}n#C9H6LF|33#rZX4Z#?)_4D2+OW&3cS2TrUi|QKl=W%`hEJ?l0D~}ev0int zHhp@l5g8?rcq>UqIygM^bfiE!BtZE|MD3v}V8@!aMY9iRMkv==hx^N%7^fSK_uexHI z^v2&14LMBrJsi^*@Ur0*UuZZa8}wqG1cpxsFSV<{Fg8+WI)j&*(EXZ-VE2=P?k78V z8EbyUZ0`L4X~X7i+~HPU?8?&Z-1G|`H(TU8#_|uqjE$ni-|W+ z0!#6Sep6XbY>Mi6^;g?QJf!K&#OchBU>Fv8knfo{aC|RwCrM(BJ7Cld%{`rY-80X2 zJE{4T8CpjaGr44*Em}yk{I0(O1Vma_-)Nyv3TaR1mGfaRr&ESN4`Ey}tt>(48?|e* z_^yBUB5Fqz;|GsV%bbi|cq}lyTtt=GMPzmLjTg#%1w*t@CIGmM7c$^*ZPwfM_gh3o z?!t?RVI-GKo7+W7??|Cj&WGW43?p$DUeO||=B~ds3^Kd^0N@g!VG-563l9tU(JAvO zq}kppF^^$nYVUGF-SwAV&)>?-)=bg9Mx#uv%#_X;MbFfZntN0BQES9=N*2pDyFf87 zF|RV;bDz)VlaA(JPUIv z+GzilF300K3QvxV0%!6!d?Z?y9^qe(N#7jYRa$$RQeA2{+SopEOlr39G^M!I?p$mYMPSl+|X7avHVdJ-^7opy2sM!L#z!sVUn*pUmp( z@L^t^0-JYgvtJcG9XJm9{Dyh4GaFY{(;6?`Fb?iNJla1Piyh`=EwIs4o4o@=mD(&o zQEsD_qGx6FsVVJ2pXTc8;$hw+*eH9{2Yr(HHnp{HN}DJpJ->_ydtMyS9rP)zzK$Q} z1@{90#sE(XY(~{)t#TSCqM#^!atSXx zjFUFbMWQ!RdMR{u`7qp$(IxI;FES?5tO(PFL8c-M09*nz7!$d7v17&PlGD}kDLC6< zOa%0Bc^o>#tY^W{Eaz-MS63FJ`>2cE5(d&Pb^vV{4r6rJ>FfC9ob964=b0wjIE{(e zd$uR~xg_*X6@tPFDwkzRrAMeLmch*GXvgIq#_dOukbKSm#I5 zsvv^Y*`V|Tb?Cf9@WllY5zIlz_(uiN;6dU~I09_v0WU4H3^vmQ;d5axii78iddR}# z`LG5nqK)KZLn@tAzHZe#u1I04i58xI%6B#k7Gh4QAEU_6iZ=I>>CV=FK*w7P;0Px6 zF<@dZUs1Qo&;@4tpg}Jtr8D|MLsS}?!dHNKcNCa+dqJ~&BQQ0m08{ftXqMj&rsj8* zjN32YrW1p?8L_lE#C1!$HJEe>ul?izpvLl9`=0d29+%pV=NsYA2; zX5fYc++4xpK-te`Ol>9)v*jKEE!S-gkC6hyf7o5;dCq$S1y#<0W{e*O*Y|HDxFx~~ z_xezpieYnS1cm&FegblYsMd7((NAQ2iBa|F%%h)3-$TQ5xG9c`$KBlOf18u)-aTZz z%1>ZRDNdq$_mJ?oX~Yrn_CB`Wxy^}w?;bp!!^c+q+nfmZ?p@n+WmR>PrMrPDHGgO| z@2Q4Ko-4*|C?Hg*2KF98lGu?8YL2T8`MIH0$|J5fvIgHM1LVKY+(krxZn}Gs=CuT847;QaV{NSmOd#;{pQ|+W3_8yn3ZZ zS+z=2o;3`qRMNd*cyU>;^^&ufI}`Ozk`x}a9O!!9hx;@6-Z$i(5u_HPnerGj*SaQ{ z;y~DOIP^hJ$uN6??yFMW%Wc1eBd!%#H1v&4K4?+)n~n^3`mwLQ@xvYNe)WPnWpsFM z`!XKDC=Av8jF#!jcSO?7JwygiJ+cl?T16J|&Z3mbB}D8{PFgv0@H(RIr$}(w#XQb} zp;?aIfG(jdM)6S>y(J8!UGxCjFdW7xuG1&*$+6p^)cE&sdXzX|{5t>d^N(H2Sj3&% ze|x<~3PT^_Q>RC!QRAC(q2@ET~R^fOi(NKkXFvK&gc$E3L z7JFn!lIaztMDaec0;t^2EF2)QBEOmwKP=B$5K9V!c0nw_s2XE&uF|AjYE`s=1*;SA zm)G?i8M8aeR9amvY>aS6aZ-Dzf8g}hC_lFL^lj-vT8@&od}>vUKtVJN@d5?$0v2pe zL)xo3;luJ|1+nkc7@tX|4v#$aq;R2H%_(VIUHcHE!sv9Mq2D1KC{R#XdMdE_A3w~b zl+w`pI?efHavfwSOj}iEc)UcJpX&K2)3vP=!*mJ{FP!6x1#XS@6k^@ zpr43MdGutl6`q!nkeI*xV`m7GjMA;!_J%K_@z7uX%Pt-HLv{H>I!3}rz_&XDNmJ=o z8SstALoWip-&^5X|5aB;37xxwy5mfmBXLo_i`v#>vP*s4hBj0aIs1GFVUQ85m* zr2)4u#=wmpxX}T(OOUro^))CG{6p z)TXpZ3}!sVYBVT~uk^O*XCqdpO} zp;y=fd;7hR`Bnm2cxEBAJKF`) z7*ObX1U5;G{m5^wM@fsoSD-qj`&a>V~Q?N7q^8W#2~V@OxkdqhSMsF>5SIx8?=zqJ(Rsu zA!<0_HBmm;`6^uI(CSWwMRv3E2>mVi+F(q zodIhxfdO&>d`fDRrj%>ZMY5mYQCc`h(p{r#r)y6yO(tffb2}Oz#}Lj4;`x<*vJjqx z824K2=JOmJL(DHO+Zgmw!Hxv=!yU#~#f9rx3CZPoy^XLO{q2?`PCbSFRFC9}n^{ zq}mOU>}15EN#_f6oF}dbc_7E26r-pP192Dq%SBvGdsNmMDK;2rYoq|cC2LKqo_$Ee zA}(?lJr+%ZEq`FYQ^c?H|2}_D`_#S6`-H?PdgzP~IVjKR_-b0#Yg)3WIK_I#nhQ)~ zC$!{C#7eeRN(OrHOYAyT_PhBqmHeWAEJv4NUFa54>$*HIa+pkQVmblVnbQEcex-^*_I}y zliWipN2cq$p&`ZHk7~~Q!Y}f)?NYjnd~(~zXv0foCsiV=GAXr!+>9w!qwnX-@?=s@ z1iBfMtwx`zM0^dhT%^IL#RhxtVB~fh6zZP}tZ)v~=w1ws$t$Y`73E-Q$x{r; z!Jt4fq(D*eO2C-SsZ(Y(3XH8&Ao(s6Yh^W|QK=T&N$z3OzSEFozGUrbZfPu~B*oAO zhiB^kfBZ1dZkmA&cZyTKk-q3L>!X76wymBi^lv-~uDzQaA70?Jh@?0%cw|;=)9)tn zx)7&Zlx(42XD$dshUa6##g@sL`^1GFPg6p}mdTp?#EBkHV}j?F$&~xVfgVpog7B6} zkNd>VjCxE1Kxf2}jB`D2#X>_g#a8(Ga~tChcUr+2GGOp8yWYnea{vI}c#5rJ;A_(1 z&MG*g1AMz9jx?R?-~Y?5HHC@e0}W z)aZKYseC1fZ%H7&bwlwDil(cA@Zp6zXfx{uZK|Nn6^f>@ z!0i=qi-n>oEpWrklY!3^z>o_znML!TkG2jh4I0Z`_aStKA}QE=vKhUYt%x<6C)EFp|+Qg@8`l4Fy z$J-C7<`_Fd+U#m^(VXbd^Q-Ctsp0#@S|^^%>BD=XHmxZhn@z&;ir5NfVt6Teyvp*< zOUqN$7EJFuq`)Yzn%iipm#7=uBymH#nCQN`-^&2jj3kW51a>x>%&Jkz(s7!tX7A;H z7oVK9KV50EPRVkY-gDFU_U}V)nF%mhYc6vz82@m4U5EG`8%7;r;C=L#v;c#i<}xFL z@iLV|)_vct4F>a?^@rxhP0bl66@FRKZ1~~pndZiL(zJCS@T+6yGaee`9VUD$RPvtUaMT*zFandHA5JB0Veq0{>rj zwbh~}!#>5Vn9kvYA`{Uz?SJEBWh~m37kby*MS0)m{@p;u$5fOjrGvYpL9&-mtEvum zT&G!utBVeHw49u2@3WbEdMN0*>CJ?`st|$4VyFo|z_GpE^}R6C$4{R9G3YGPtawSl zrUm{LsNDsxS@j5JVDc7bpyG*0e$U=wb>TtQVZ90gn*uN^ans8ReU%Lx?FP)4J|7s@ z%*NYdP3rJ>KRTen8r!=t$WPnCZrS(n_DEQ9wAE`&K6tP6*HOY44{EgN(f&0JsEbSiBB)|HA^i|1H)ZWv3i@ z#dUv@S3qX$!eoIV$98UmVG(2I!T->EZ${aE=1krmf!TOOjV(X-G0a`$zuq~JQ8SV9 z@(HKkfWv~+#>FRPk`A0QtOjVJ!B_Rge<8r1%Huje7Cb1O>n*kwYe^+bE!oGtAZH^Z zlYF*yCa~{N3~8_qR-flDikcElhC7R9O@sR7vNA-IS>|Eg!*G_er&*gp%O@hK=`4bx z&uaH#4Z;nIJ>D<(%ia|bTG{TM{HC>)%)Ii1yg-zU^;6G+9P5R1|`RmtqSwFBbq0c8$OgM5=z~|gfl?;Dj6OS-kWf$pb_=Tn? zS#{!Wwu|#4LlxcG41rFBnF;xbTe}@vi-J>~oSntCQD+mxvhU>HJ;(ZzTiM3JQ>GRY z6q+n@aH*#km}-hQ6X*=pPh1=4-t-e*sMsPo;<f*DpLZf$*;>ngvp4#q3&%JK% zChq8%E&V0c7K>q9LdaAKm^v^4Q+&u&9GEhw0Mqj>VCo4>O_f`^zSwRq0#gBC%FPH& zTjhZ%FEr|XU|Iy3T0o=T;~fj~dKIifoh5b$gSP$M+7Zc=!pmoPK|Gqc1(?Ok+Tt@mf#zZ+@_FU&w=9ids+V`KL8`Qt$@R9~uNqA7<@=p+SGS>&d0b*Q$oj zdXFn@ovpU-ZS-T^ZX7HevrVHT?wp{v`t3|uXU|dT-2*)#y+&^m-e;g}@oZDX>lXXd zvSe%b=;uF2-~%IYf!pB2j5d}(BsO`MKayiV-fL?vO)n=BMJH z<(DAR$3DM*|HgSepLUj^^zGkT7JBhfL@m6>UiY`tqr(}4$`3C-0tLEipth&%<7NH0 zT+P|&u@fSbw<9iy&X@F+Bi(I=SBhL_#gA1Eo9MX5x{=JlrFZe;C~#Rh-i`DWTqYDh z9)Nl$yOC_bWohx_8%LmbsvF4xTy_9oaLGO0jpPC@XMr!&JJXHi4la*?FVs8NjpTjR z)7Sh-G+VIw)AjL;ILs(GE+z(q?rS8}VE^zd&7+7^q$bMEgi<;T>k;&F(Mnk1L8$KQ zm_TMB{3%OfDb6UBL1kIl!$;#Rx7P6qdC<_$`~#jfH?tcU#FmxGJ{rGyYyAcx4@&IC zCy(fXsr&g?U6)T}4w2EFBqqvxJ71Z|9NyxtutSaQoRcpnrF@^F0n?Q)QDvWgI!6f1 zH|aEy9vD(VqEW}YIVfPL#TZ05a8nxn5gaRiC48|DLD~FL%1!?4;1%&>yh{$So8a3! zS*TIhaDUu{BlkfF<@3S%2*)=-FSffk*($noRk1_0EKZwV>xWb(MuJWaN2ekMA9oE` z%$FTuRhQdD;s&0t593@q-CXu?2l7RnU3wYgx<1=_h+EcWKz3SrTK*X60q$;J$%VWU z6`s#E#*Yti=Tx~C{LUE{1PqiCMRgMKzDu2;OYd!&uFOqOt~=d3S18TeQ;F_#ZZaiXz{t>!+mgW z--Py}C(306vcI9OFGNoX!Fund3c@!ZiZa@}9mHQSM{hj|(su5&pQ%CxGJBc-1jc|l z)94Lj$&)6i%nFrPZA-~FR8Z%neVcegqc;eV;%y?P#=St6B?*EDnW0H4ZBqG$loCw5K~;xOx83};dq%iH(6F=1jlIkH^dZTdw2yg)V4S=`V7Q4;#66W@>8*Z0<{MQ zp~*atJjDp30#vOtFwOl4pCz(j7Ku<}qkaE`xA3_J^$2AfMy+r2GafHrdJP@Tp3ZLA z9j!Y5u$0R~vN2msJo$VJC~K^mD$#(XW^9%u0H|kPZ&^Wl`wbTcNN?ZJL*skWDDYvO zCUL7UyN3+AsCh|4d?e^u0n^trLHc@nR7hWsiwGnxc3nUVGhN#XR4_AjIgqCQgFkev zHHMBgQb1qtrwkA2>v3Tlj_<%W96yI7GE%S&$LC-hjvoSX%qLXXhT}J38;*YrbJ_|g zasiTjJ_F!VjOPSy=IjeJ^}I^GZMAEos6b8M;Bu4Q`Np#=&8r6P4g~N_yMMr8XIpq9 z@FMAF0XVQPluI!O-@#$`&Ns&e_YYT4KD8m$@Q&V|PU%VU*m(mCeq-kV*)YV8oyU%O zJU|+RvZzy6&UlWq7VpM1$>N~X=>J66(p2nw2vqUO8`UF-8!pKk!p44wf_;aR+W!+O zuoProXRLiq>z4PR`wOQ7VgAIWZqfflio**@acDPYg>PO)-V>A%@0s?_Df@0)TJ~L0 zMzrYZNsqX0&+M6jZjV0Js`lj!_L_DGY3Y4@SH`jG^Y0lY-?uKxO1^WPIk9$9YTflP9~oF*!gV$E>AjY2ay?OH zW?HBV>r2DgohP;LV^(HRFb5F!#S$ouqYzkpB5%XVKMJA4Kwn^ZXax8Cg0IHkd`VZW zBX8rEK;;9u$->q{_5x}(@s!;fzf@hty>CIXRC5v_GyBd8UC)AolISy$W#)H=9Z^VR2cCtm#RPzP) z&g0{T#V!)W!yvPZM(Y|7U*D{tr>Y2HP!0wKy}`ix=I^v3TN6RhdFDY-)WZ)Rt;@n4 zzs`(ZtSm6RTqFRautK9`y@DaSJ_`U`V!8(O$a>6xg#hgAfb#2%@#`E@p9Mp+oSp$) zX<5v}@x|^Ow(2`I*9|S(y8=*kOkb2#c_qBd-a;B44t}6W-(<>g0(bJM<>XV}`V%2S zs_@d?xGyj9RvpZ$lD1OygDziH(5401mqr)`=)bfxuhC>{ng|ej=rd>_6Exu_5V4U; zSm~Ob=FBzOr8#I|W#dB3J<2_*jBz>=aex8-I}JSb>YSa>JGW!#rJ8UEUxsp$cl$MN zT70NW-zA;5D2cW&X)2GS@VpwmIOHTR+GA0A6BmA6COK6ybtsT47gM8K0H1kHCEH3O zqym+on+Kn1N+tbk(C(s$IwN)_pDRjrml4x_N=cJle6(1`0!2-=grXdF3jhh-p%F>X z>EXcIoWh{fS__KRm^@S`c^lqF%GI@)8EX&W;W7G#>0`J2Qbo7AodXs9gnj3QwaiBL zm5uf>NlD#`nA)7^+8p5X5c>eDGLwB}HM7xLJE%7285n!Yfbh%uB!6Y%&an>rRoc_h z6P#`2hZlwZrzcFw4)xlS@6a+!L`~K~uku%rW(;$9g+2rYJY2NZQ$tw}Pxb zdU`H={kn}Y?{nI^Ph=CAGo9AkGXJuxnC_|ku-=U3?jV-JcHG><%CD#GBHQ>&tnmRS z_(UqfAw^;|dg?TJXo!LzX$eDHvpPat-oca8UaQ^Cs=Z;NxV4TRhVldV1wOJ0e4JPU zZZ8{RFA8NQoM9O*=MTHNunk7QLb4qjGLGM*K+#`^FC>z6?IK2>fIIY~ctSJ|cet^W zlR@gQKSCDH60#pfS-0i%#TYP;vHg3W9Fo^d+%4>HDuP_-pR^%JYLfitdK5RW&YtSdx3{x_ogS@zKSzSozxnb+HdW1H_Pqs1DF zA-TO2L()@0VhFqDiGbpJQ~bxn?xqTMqPqxacK{^O?r!-s5Vo?Nd8Lnq({=daKEu8>*}kI@f-{WgtH}q4e?2vyQrhQMTG*ay!9W zz#S^ z>ZUTLpABq!!XP=Y319@ngQ(3|CKvi{-4J^+RcqSrXVNvrOfGEQx?%RbSzp7MTv)rO zL+!VuYmTzMBCBrtF&(MKoiUk}rYx?<|9|IrXu2=*`LdXjzk%YM^aF2pee0*V8lgkZ zp9O_&-f*)EKXq}Vc-MelHxqDwD@Cu0%AlvNY(aN?n|+#jSuO} z&HTb|nwCX~1_F>z-QjUCdRzr;Z&KYZTK!%Hds)dg#lE+lXY}~dLS1FMnKQphsysz( zEy2B2++Bg4ug@%9dneK?Kl9+OV(eh-a0s`Wk$)=~>KJioI99XR7mTp za|_3G9zGgSWmRHhh^XM4wY+&Cvg(?`eeuL#sg<7V!pZ50NO&}RQg)x>RnwDkE-MxsSO^xYbylW|`UOL37Z>U6EB$XlI^ zg!kx^?$alQdl-HK7cc+Klhq%CbTbkbfkFPAljTXPMC!UST2f!bVDz__g)_FVv^mSy zbSQ=mWoNPT`$qhRKX+MG;8w(-YIWtLEPCC!qYQO^&mJp1khwt5Zjx z^$qk5Tp&swb<0@Sz9DH6Ewq~c;?;6K+i`d?-j7$qFS`WkdRF!6xvo)3JG_j}oo8A` zNt|MAs?Oe8-fK+7Kt~Ehk_qT&{_$8SE>*{5VN``bt~qlUGuMhqLz0nOr zH**+0_c7Cm1T&#R@ql`!<_{3AZ$B+C8CB~k%6+A!$X5AE+mx-kSKBhFdYJ29bXeuQ zA~9pb!`9ZK-X!cvcleAg3V-=Lwa`EBzKHC6d=|rUQDNMb%&d;C4I4tUBm(?`_~nk6 zh_UnK%OsE1TZ=b$;kZvcl053~iRdy=vB&nm>XPkQj5XQ)#C7sG$)o6=hz0`{OKg8! zk^)zh0@sa`dr8s#aU}oMN!}xGePc!Bk(w%5la?TOnJ>0F{r!m7Zn0Z4|2N!hN9p2o zmz~ca`#+Xi&!r1&mY!5bGQo%5-dbHbdn=mJ20BE&+pijHl|#5nxJ&xeSDH%CzP!iS z#MrDfJ8%f!Fy4N-Ur4dyj&s$f8E)iXcjpqI6K22ntBA0UJoiib@j{(4c_ymY^Vr zQdB^YjtE#NA}GB{iAo7gLJtBOFhGC=0)&t|JNi98J?Gqi-uK@7u%5lco;|Z?&#W~w z>oaSu%{luv*iPdRWF!=z$uH8y%*zWL#Ja)GB{bLW1G6>oZ2QBc_1p2o=_xend}Q=c z7TB5$2V0XuVE3{Na%f`)Q?dv&B{xR1YbxVS%{F+v^}%)O2C$~Z0K1`jP~^%AFfD={ z-9kJrXpS%E>m-s=W{TdtAg{LTCX{BBhGsZZrgJh@0$HfZVkFASTuCd&bNEVQMO^@l zM!=NT#pc$+Sv--I~@iZ00n_cQ52~jF3C4NeTk{JcNGpr@7vQL9Ax;lK!7v z?N`65<#%ahf8SxC;>glb`8fvphPL%~m;qrwS`-An1o>j%erWB71OJ2=T)4n%$D!oz zDY{z0IdZvXqi;*n{g&wJ2hPivqcVz`+Xk*U;NKR#pSv;Nejk8jW0rpJ)!)5&|Jbf5 zcJ9W_s~6ysHJ5~kz7BsX9ysauo^$26mUj22p*trzxm0flWj~%`icJ@Ho8D$9DZ69% zU_Wo&SVVPJdbjKM2z_~3(nYNt^cS|!^A}QH>e5AvEM}nLA z?h9Fo13Q@SNaPZ^1`H%vr`JR*OI|t{f&!BFD=~xn9?R_zg1|U8^h(@0Zs4S*Z=|At z=H_Dtwg)=DZ4cf%<Qh4^bC|V8A8P z12q59|E%Vq$cu3`v!jlza{`@jb&pwb13SY7PiCk|o@7R5|E^}LUAr!1SKlMjuEI>O zDd(?>%>K4CoY9@;SPBzVa+YccI;I68fmF6~fp{U=Mz|2V(O^9O8?C;l_a#W}NxgFg)U`y`tFGs?vUueA$aqzhh) z@vasg_n9WcG)HB2?7VZ-?eq?2#ybWQZQCcSpQGMw2XdD?FX6_@d`F^!jS&Xk+gQUa zM|_b9@d792P-vTe(a`Q^M>wX~bR}4yo3(|(tJ0jCkMUmj3vPNrF}ot1BPsXEr~(?- z5d)UGtB>4gvlgp#4=_k)wF`jI^e@KWy(((9{-5~x$!V$>+7sP+qBY2Gc#cKuJ zV;+i1+T!moNxIaRanplgu(!~IVXXcNhC%!l48s@1y#T>5yrA$Giy1ee(^|%L=tRo6 zwpOy>zs`IN@=B|sd!;ErUTM<&5ahBc?vrEutCS$pTlj)WJ(L& z7w$Ses{lPK-4~9B?hAK{?hD68_l1LyzfhlOx-Z-*;0u?z1|fgyhXv_bndw>SzHkuo zSM57V_k~-e`@(HNzHn@GUpOblf!64~L8W>{STBVE*=VI`&)e_M?f4kP3xuaaju8s9 za>_@6?jkw*S|gSA?%;Od0jgATgm%q$CtxyF6$usq9be{Sax#b+AwCr4WjAJ!n^e6K zWpBXoQu!nYaKdzK+tUd+dddP#>gqP$uH%S`J-oa5pe6`3;jhJb0tl)gJnty|oE2q5 zm($Ttr3!Sn6T4q-Cv87|yPfD=c$zN{fOVb>>8JcYAjZVWDh4$Ovi@L~1KAj{;{@w2 zwj~LBG8{he?I*xABKDT1m9fgoWY29aZ^> zcwOlmmOn-I&_5#UuRZ{(>Ga65uIvp266atN~s6(K_R8vSMGug#J4{5@K^XtE~JwW$!t&hX-9w@FzTf zpk>|q+i#U86@%q5Q^7(2I5Vd85HPEGA1@ciHArv;#g|+RMu#Wr^R!A;^ zumZV+g!RfVVYP!!)5{O&k!wtVv#M~i1wC>N4}`4u?tqYWIUtl{)g*f48puIazp@-U zRwqKoDj!2Aat%K{at#3DhpYL(3SlgmxNEcvUcSJ4vXqBn^CWt@zg`Pupo7ijW+pEd{X_2 zNdp-oby4CR)RXksL?-qLK688Rp#`BdTw@~>@4SS2Q z4+q4Lw*f-9;WJ@Rxfw>fEUI z6uE$@6idiB!@j z^Ur9#xj9Rd$Mm2nB1T`XBGp|F7QIEgBp{+9FD)s_uPN_}MYG4C*$e4(BTKMfU&SrN zrF*R-d*zuSUM0K^&AzIyqPf;FF`*Lf{E0nopNi(amI;+U#r#WfGK~sCrN3|0Yflb!Scbz}&vPDb~pC(LiPomSwWk$)sJ4v;TCiYgQ z5Oo{V$;7_f#Qtq^t)pTf2t0E)e0sal=Us986g}7Ppf6iI*?X2w0-txqOm9EG%qSmd zc!*AtfrfyFp1^$_EVW-`+Rh5EZ)7+Ps}( znQ{5)OeN_gzhWxC(thb@^80>8;a3joryJb!5JM)^+lnjgb^VH5ryF!5HuB!UH#UAM z_bb}j^`DdC`$ z9K`I;)cShh25Wi&Lt6Qo(61=}%HjO!230zhpKbtDn1{G%N`3cuAMg59o zPzu-WC>P9O>qaP8QmvD2_aSjX(~fEr{K}=9%ha&f6Mm0O6+WGvBC-L(LlixX;|0EA zLce^)j_LPA(k~I#wb+-Tc}m@yPFJMTl%AN|e3mJ^%KM&9u~&Hk z711g9v&`xfa}lXDO=EShM0a38&z5{{%^fE-bX*#uh{x_9jn%J6r@eh*-cKjhC+2|4 z=`<&uHfXBu^~ilvVyMOX9eA{i?fGwI83|W;ljwBv9h>A(M3VbQ6Lo7-h!CQ<<2Q(( zu4P(*rcOP=niH>SQe_q_q||@T$&TA$PWTP42NIZ|#9TuUu9IUzg_Eg2c|!K>UKJe0 zsqI^R)(ss6Tfq@{^+XKX`SUsfZ2dm)>H!z(A~YX!0pnq9Nd1O9P1%9^Z40U2kf$jx z(A=Y;Ff?=xJ^j;N;MKzhu4zHq{2idRvw&>8kk(EE+Bpem=dKMP+q(I5Jpk7?z_ku= zO%~GF2|#1N4m5Uj5XjaGLeqHLgKW!j7*pWE+F-^exnD^-GX^!eQB^X)J%CHqyZNFEoTGH|7&6|mUlQaAV&A?xwq&jn4THFJ(yD_$s5BhHSz2e zS+c9g*8tO$ZpTXN_H4X;I&pL3vSLlT6yqkB=_xZ7XYH9xcE74ShqHI3`Y>EvD|~bh zz4PLl$gAD;RZRV7E?3*jewet>GWI-)+3-e;g5Bj{zkda@ciCi3i7DB2$zgAK{b3tQ zwc|YgZfwae_4>nu8`X|@{M}%Oy`z-si6+c;uKL3PB;Tgol3kf0c8k;ayZJls8G?{A zj5ElZ$6vCOAaXpE1U^s`9($HW_!awy(}M1KM=F!QOxPa`XMM#k_TorD;+F~QgWpq`zWM*FG?6%Nr-Nx6tO(1&vlwQV3dKs7LWsI6$^HfY~3O~!jby`r@f52Luo&wUpsP4b<%|MDfI%RM5iT$T|5*hQlUqF7*cdX1Z&6Sc3_9e=-NSGg$ z;J%;2U%h?5;qJ4HN!>4a=x%0a87CG$!t5 zN;25*a|)ESEMg!Pbk;zs{NE~^qMHUjPglmKdNlbYJC8J);rMf-?Z=PS7)$+C?N?x= zA~A$o<#AD^elM2O{(Z6hc_~gko8xtPPL@cWBqvalJrg7jFz?JcwU4gd3hccvuT|g8 zQf`=}PD;pC1lq5G$Soe`dj|Vd<>+0)J;m5_F~xZ!Oml`O%FvZ%IZRiA%U|H`$?V;! zs*E5k%%l5au#+{(DTdjc)%{nxGwy)&PtBr{*}L5$WMV=34yos;_#RFf7w(tghkXTn z+(0_hvS-vjH)f%nQ<5N^F?wc6GSzT%>VmkwJ{2kHuEeCC!XVrc#^KV)qT(1X__m3C z&~d-I)Tc)iNAK=r1CehYO&H!~VcR2R%nf8%1Ce!w$=K zGx!*Ub4oCM+IHko%0V5I&C7WfzH7hYxm-S!C}Digw98p~)m8nw%O~*B4%yqCA+GyD zK${QPi}!)q4W2;P>^uGGn*FK{q}eZR>ENN$H=QZyw4?)R5KFT`1hueV&6tr?D3FdA4GVw?cl?CJoVP5fb6>~@2=b%TC~d3x*!68Gs-XEOlpJ6 z3JT|N3nSWzyclNkKkk~1jQv_`yA%yLZp#uK_B`iiX1)?3^pf#)wjn?F_TvoJl^Ujl zV_7ndJ8g2p_<<=^lv5+X_P%huWKhd)^Gv;S1E~FvXC55s8+rcH!1~T>`)o%36(518 zg}XsGgMt42kC;I)164UlTqXFpI%MY1u&Y;CNpG2g1{w6`!o>UxxFEOF-sZNsx5`>P zqi>bf+&kEXd7Im6-zpz+@7S3p0X%2eOr!)JOB}z;#ilJa_y|~5?o#G=?_d_@-Pgn< z+}GHq@K%}4y@NscOk*4STV;khT+#8*`=KGgD_H#sa!G3^7&QV;{`S2^4HQ2|-jFJVXAtXLu#t{4dPe(c_N(xcc@n$;wXr}hC4dvEp~?$NkF z=4}iCh7875jQn5^`{H(PhU43I-xu6H^EOSN1H`)ewtYy+EZXk?b9xx>ZdqVbW@W~9 zmJvV>rGbzW9dES!q5SS_!9S@tJNjaGigRH9(Fe;MpZ9p-&@0r1m;x@uQ?4b zFu_i1cumMo{%ha6KH3?GQhl^!eKb>j^c0XKz1{QXB6H><(5|<+$gKJP?iw%sPmv*o z1uQhw^9(~;nNv5dFw?!;^2wdYS&wP_MhF(@Z|lGa2z6NGPBV#;`-bKG*dQ8#)Y(Dv z6WF>bLcJ-nc~gV}JdbXQtVcI`OjUYJz4e%S=`oeJxc}3LX4{Bn%ZTR35zWStTOnLL!s1gEEELr9 zbi+);EjE^QDK>#w!C8mvFI=--voZSJ4s45U>*)aCiTQ5eF{cG=K|h(_1#3D6STAuG zi3!md|F{aJQ$R3aJD_a#YJ8}a5#Ui$$`jiG)^M4`Xy5qoviCzp3#^v+zW)Pjn;zTQ zhaY(%FjMMpF!OntyM}&fWenO%_~QhB-}46-ty^Ebbh0?B z422P9J9<`G{B;WFxsJ$#GROG6a~{01YBhW51cediQGMyO=d3c@>lCJQW_J#{81VCE zKbUHG(A@AKmv+*R6#3sr^zrv=#T(AX}@PqSLgu%6RiA@!+tF;wx zMAdHwgW#}2ORLuT&j@o67V~Rd^`d4#h-u||mnJZO97VVagK>Bq=_&+H`XR1@&vS_oDtPqN zRl1qvG~G-R!eyH1xQq{k%VeduJe+62Hhe|$N_MNA29D%4N!!@&_8&NVNj7UNpZ-C@ z`Qyc*ruYI{wb$^%*N!)#^Iz*%Z(sx7d(;kB*w0@sSq-KWYso4gBRa{JtOByY)McK3 zPCiK*zdwGtCs;nn;o&&uIXQMFR5A$rV7%fvIk<;XH$ycfZAkEfRe!T?CHW)0V(n+*Qc(|-WV+#PORCNd9s$ek6@!idT%kn>1wZ|+RyV$@?e@IXKTu-{Ru58 zd#Yul|6|?uzU79InzdZq1+iDMF7K~L9n+81ytMox-`L#i42ifyhm!DoQtf3EI>y=S z9V|^N>HLsu*>%*h<3*ZZ*byDarplNA;UNkic4d8!<`l{jRn^yV3-#;Xm~$kQ0fdH= zQ(s4OZEix~9YAO}E%s??p1Ng4Cr2p_r6nRZWJs!^5Xpj6QS3Ed_y_okU9H z9|!HY$%j}o&;hP(=VcEk=e#!_T zhgj8mq3fY)y&E^K&cAv5zT~8Oz0lCwjjQ-KkBdr9E*w+4E&lp(lvS*5#EofXKFN6C z8@@B|Q^MK(@~@7cKOL<~r}ER$fC}??E}BZedu(!5GU?O#gO7{O?kAs)9yOI-mPq<^ z?B((5op~jRV#lO=&m9QOBLSq& zU+|VrFGDS?De2Fbv`$QUKTx0MyZK3Obzi|?RQe?M?FYv`$;Is}(2Pu<-p>+I>6$I z^;tRzd_E9!mGAtKo$`Vw4$(2yUZSLunh&F2G!SNY!4DfTKKprWgM^AfoMxsK*dm(Dd+m-KohzLC3drnvsp zzabJyA_O<4;cOG(jn6$gU_O=L)L^@NG@Cn>5852$zVCIX^2yZ0&i&^m4dWJD4;Quj zN{5sldt*^c-HjW}`06kERtH~OQ&w;O7?FR^Y!}SI<&vh&xeWDfD#|e_jV+7kWFwW2 zb?;C;ns8ELw=pwM&lJiH$Dp#K-!NI5{rvgItkVpEmCf9$jIrG>p!7S(No&f(p$3#Y z7P_{(3uum?x0r;u6DQ}iv~@HMkEX3OY&Fox zv?b&gA&rJZY7uGfA4WP?(d34PF6~8B4#09MaUL5r$gRk|5f|2yBQCVJe_#2A+(C=l zRQyI;Ctg5=ZA|Mg<-RMUEkgt6h~Dkt?Fm`p)VYF(1zpIY@0L2Wo6D$-&~@@ADwB3; z-5ZUhen&TKQe9co^*p_rhFJH?+SYn{H4ky^HL}(9@@j3}yVupW*2@buB#!LjT=!o6 zlvQTBwOQBJq{egDzM+~rNiLgGTv{eCpSK-trMg- z4ihFK2^WW?A8mf~0DI0zc;{>8G0)bNWSeG6z*^P{T0JpK7oD>n* zYrk0+@kRQ4SJUn2O!%7Z6pqIrc}I0*w{&E&p-=2{xPaZ{jF2(LxH_^|?P+n7Pi#J1 z({6HB$O?16I_BGtbZtACy4dzpIhKFnWqsrcBqZ$}Mh5XPFIJ?Gn2hi~*3T`xZ7;5t{siOA?F zQP~W|QXo#>g3*wG*QdO*iK90|IOi5@&uq#sxZuh5I^SJmuF+uBA#c6*L|2itB88PX zII+{VK7Dekbm-fgwXGqqg~5xL-MjeP&p3q?3LTvbZ^8?}RHsIral>sts@j(2oHuP& zYRdKyQD4Uhu4^_5dmgqrIdq!HET)~tF0#T>BeB8VqkUmm?b{q@o;^V}_|f!q4pX<1 zKfnXH8Xec-4?WsuQNo-z;B$t28eaxD?2?LIUtNFoesVt6w8-2mKG<~ZA%1FfN{n1t z@GaAF8?ESc!6{@&ChR>EOL&u`k^nnPxWo3W3YW#cu>OLj5+W$WSKl}n*%u_479>z;Uu%;oiTjezU5 zDa*g-=-E9iM|IY%>CyAOhg{(3gNDdWuO;W7s8$WrL#zg|xWWVm+p zkEdD`@$|yXXm43+BgHI~Qns!@X^K%4YO{{e{onO(aun6P#W&nz7}M%hYEyVV&4T>^ z-`#%_g*^L@>Ryt45tSn5#1X&|n(nBi*8;t`JtsNnKF1;Y?_YHj@!ct?eg9WYZv0zK z#MHUt&$G>n=Ob;H?2mED3YgL8)l6=tZe3ZG_~(VflO`&y@9X_4Ca z{!lom$Jf8>;Xz@2@^+Up)E7{#3z=oR3#o7W8fOO?{RkLtYm&X zR1rl`5pjCX7_8qR^L+yZJ{&OjrWqz81nwC3FW?#{5{g{KBGd0lAL5- z_WXGIBig^+qGs_w68$X#v_|ogxBL!;{>3f3*4MZF zZknIv|JK0&`=+T0ZShcG5BrBd4=%nvGZVXYh2Gmq!^h7XM05Wm9|K_(eFq~*9DN$l zd-;R+^7#E;x3G&k4;g>SFA%Gpx^vt?1s(!W1KZ@OKjydE&-_p8t4++8@7x#KOyYny z!e_>q!)Jw|=2*O4Iij)I`h45JSc{QMC!&5v_*cukGQYY#amPQEbmR!oDLQJ5RSInu zS`-S>XmZ?$gwkq77FIbLdNlv3Fblr1=kc@;r!yo(Z@%XDGCqj-S0!0$Gi)SZ_@|6t z0dh!9b5yEphSKag{ez>hv!Z|W(TvUQps3$+c;-68i9Z;3+@f%IuZ|f38WFb4l|W&? z7_O$S*@49Q&pS71d-|wq)iwWS{#WH;`~MIj57~hov!eO_kO0wS1k4Cf5#h_cq49HG;eFf=^w>@?%+ zwNk_b-5*S=OW`_Gsl3;9piNnGbGTBKt7+o&+NciSj~%a)?jB5)jwsFzha=LisJ@V^K1F=y+MSF|pycDH#w8)z%VGw=(ELS#NVDzCepx@>GYW7ol$Y zG%Qs<+uRtQ(jGxqh>aA4BBn|MhjGYTG*m*wEr*fusZgJWmCB6G4N%MoxX1>3?eCnhTG)CVo|6PuiTB3v61={L}&1Q&gfj<_?t6 zY~4#VfJ3)G#+1m-e)!(hhij`RTpXr{kouJU$>W&SA@cWY4%6?@==x9a0L1FOLzKxt3rbu!o7i~e$(fkTWrH_bPTcKPbQ^}pERIlq|cboD&N5ihp zxMi-2_^7hNx_e^sas?l@=4+>NaCAyGq)kqty=Gh1{Rs@MD7A@RuWZ3HA-1gcOk8SH zy}Hcdrr%!X1m2#1jBwd_HtULbis*MG6y#++L%7USBS_v)5r~av(a5?jags`z5%Ckj z#rzwtk`%HA%7gEOH|9+lsJNJ4`STTdsYY`>x=UI!Zk&khTtQPKl|2v5{Zv8j)O@K# z@pk7g@pyW^{LMkmty)_ox`0k^S=d5OT%*FFIf41>i-Y0n_fy3V2 z7?Di_2bHJwE`VJY;2%h8@te1HK7yh05^&f$Rz3*~o!iV9ZvWMyp`8i%c#>Kl#>|0O zM#|FKU8=eu2@P?ul3mo?RUW)c*rAYaHpm+EWxd?(Zv ztyB(o9#g91vk(=ubbwl>1hfpOODMf%Fzz#O`>!t|7_SCG6`*q(sL>rvz zc51lzj9Xi84_G87h<55+N;N`gd`E%id_@G=zr_FI`2XNs;`C2Ry-pHf-%SO*SLpFG zrj{ytox{O9XJ-|tnc}Mv}$e7QSV%)#g-ne#$@aXSd%vx}30mBeg)6HMFyd zi=^f}3kUQ6tNI_0PFsc9w*Q}CnT=Ge&1vJUTTl6*%0xkxdGSwW`2MQQ4TGTEtiWFH zZZwc3n95TGBug`{h}>i#igLPJBFPr1AiGt7Ez@C9)>P$ts6Sa>Z1sp`kxnnlOk5?j z1Kk_7F&A1+Qtm?)*2O>4hj>Sv&O3GbKm4EaK50n%9s$YHH%OLbf6LPMh(8OA6N(?7 zb{Wa?4w&f~rq{!;A zhIW9iQg)to23-}c{{vj?Ye@SD%?2-^+2Gzkvq8XLv%wW{Vt=(HRD(X$rb6gT^th2J z)KtTi9kWvqFDuh|8Sjh`_PAQCT^51YmF(br-KFqtvo09VcFy&w=hpZjjn=mk@w2QZ zle=DHm6E@?fYs}pLLQSxHv8)B3-OpEJX@~lT+t|LHd@Dq*VVFORw5SbO3BV&f>kiV zA3l&%1cFY8xUj}C(G!&Q&Azn(<91=x#3Fpk*OQ0co(Cn{)c09;UTfwmm}L?KO=Y23 z#^*@GnA^2{lJTrHHZit$Ds@rY>8Nl%sZxeM&)_Gd1Zt(kJ{++u*6nRKQ&gz~9Pn^s zuCAPPq_4fOF8Pr?!~u%GIKcjgzxp-Mg{vpm!RRgsjqc+IemA*C;$JLa8D5YKjqdG$ zBNbJi+S57m8p8GRkH=W^*(F@1&+sN#O!Q9unjGZxivO6t7vCla-v0jB-X-YS>@~zw zdoTg#OcrL^2a zHfTYxq^-%uq8L5J`)&3bSP+no0G4cz$xDVuVDkD80%#6(@$X2k1A4`*C6Y4b zS4`sJAEBj9EvLoZCez6)ip1$Jl64(Wn`|o70S+)Vg_>$Om~Hku!~sVj4ro|OU?yT| zrDN%Ph1!I8^fxo&(L{F2gPOiO!6g~XDjR(d@v0LAu;60XXUj3v>+Nb(ho3{3A8Az~ zTCFJR?10)lk{=7x=@Qj}KkTe>3N(o!7gS+#pXEiM<(CqKo&e@FmaReo-U2{F zgcf{>jliKvMxB3cO@WppLtptrnvAaE!o0Ff*`59_2FwsMT~i&r@cwgc*pWY1m<8wA zN+{8*UjB+ba+NiTZk(fIWkf+Q{|3{=<;oh&et|*`fATXXpoYBNGfEI2&l9>o6`yG5 z%DZIEM2(lvcaZ=;lCloJ*rEl);G6#J@j@>*6Zfq^f~1u>yVP(cpx@wo0mrKb*DqLg z47OGV>d#0cjrDKHKgS}{r>qq3XZ+4dtqkv0GX>s8yk1Fw)L72u67}ozCX4u^x;1L01(lH|tf=gc1v5(~P*KnU2se zkE?&dak;3ie2X3%qok`^*lGQvfnThfOC~9QG&JC)SECW0X4O z*2!=(wrr}GfV^H4N#4dDNgHIGov?g!{MA=%e_g-Hg2zJM`3o2y#rKS#>t@La?*Tn> zC3z$muT_&C3_)^FYcT|_QStqFs=vn^D1$;J18Vi(#bG7lyh7rp z1u<`kF%|LgARk+7{8ut+eraiQLpi6kv<}wg0FxoPO-RY&A!V%i`ztfRT@EZ^5pwsy&FfHkEJ`E95yOaNwrgha#qA z+#N719d>FTe7SuIvyw0OunULD4`Q#m*S~~`#blihy)!mBRfO?<*wR1?oO=K2EWxfq zA`tI8_7N`vE4gg!fF;Ia-k+vAk2%djw|(^9tiAO(Bo>XaJAQGBSTus1QhR^a!Lniy z2{N6C&_dYz_c%kzXD@-|G33~Z9yNXJFx6<2`UA(&<)jfW)`ox|KJo#zk?WmmMD|4M zp}y3yhOSplRa3)h4#Fk-SX8IfTDA#vtTC}DhAdczoO~TP*YEoqF?BUM!u%yNuYez( zqFpouTcf>S5^^$7u|Ec|o*0T;vSr<4;aCuy?!iB}6vfe0h&IY8#MlKoEbrAWK z;*1ONMn0oByPA1tQG^!!DV_Q0HSM7b;J;DiJxchv6UEJAXw2g{A6RX;knkUd}PaoY3+`cpn7qMi| zCkgwL-)8i}HfQiP6tu-G!EOX!6Wm}i8~=TUSYKa5m`&U=vq$3{W>?1a6bnd2OF`hj zK)n*=Jq*A&?bi@f#2ZI-_iADr-Wzad1uiYEyIEhI+xD$rP_Sy3a=e(ku3x3c&$$>^ zMeXnU>>EAD5>T8+EHbJ}3XSh@UTs$7>44!sfHt90*ke1#!-*7N|<#sS4whmY;>e-jxcW= zxj6D}Vli1yTdkVBSXJQI;JZ*}DQC)x)6SpAha&B%RK=T^-N#bB0y*8<^46mcU5}#X zs+^5Ijc*wf!mZoi==A@IuU2a!*7a+A@PVQw?ZoO=xOk$r zJqjN%2Cpl|=nUdTM243XJl#3+-wxX)ftC6t}`)R{>VJ zqzoZ{=YTKhbmICz4~GV=vTP5H=Z&|XLwT{@OGnOmQab;ymoFQ-YXA1C96mGDCn#a$ zW>tYJe#gU=4OUvi2fJhJ;AOE$g%9bXenFk*rJucX()g}+=KR3Zkj})fa-Aj5-tGSg z59l0(=bw!Z}owuWlOEC!6hU;<%mm%%2Qqa)xwd6mY=rhy^5X-KVHqYM$Zk3dyllS&7l!p9yilp zJPnNNRkt_{M!>;qH`B|DrmEiB%-vScFi^1DQF9Y{p1B=gaqWRU{{G`E$_)R`i}=O7 z^QKsn*a=Y%o~E=M>t6ARm6eQ>S#Jq1XjclAA@ny#gP&lL`InL5p9Z{5J6E}Y1F8=M%r(ySvz|xR^9nMpi*$E| zej%`Y-<4?BO9@D^_yXUrv2CebVk^yw%3G!66+~Yf54v227US)enV)lkxOd5?{UrXj zenIs)-)dKfqFh!whsF9y9kX%1yO{Q_-D7@KI@z_Ns-QBDrawoRD@!&rp>RF?3Xdu} zqGH=hx(2h||h1^u?BWW1<2%GsAHKk+_+aeASv& zjXJr8_wb8)Rn+yoysYbSy3-Y_J?JOXh)k_=GMQi+M0}W+<;+np5Fa0?A5I#M$!}P@QRDfwM-_c?t?s_?h=MJ7iOQA z+g%=FygX1`XLhI6$#m!nlI2`fyLVyU&$p59AIVW}PJe*ET%U>}s*GYO5*3FW%32|_ zyp|6m4oj=B57i`C?GYzl~ zyu91-tQz>zr9t)u6z{!Zu9^3!0cYVcLgtbmZDr|r&eHS#09yzau5tZf9vF(Gtydut zy4G%W+!bOPVj4Zvg=aU;*ki}C4x-S6Rk%Ku2#Tq*e6lK5AyxsUUWHPb=&8o~Q$&A? zS=JJL!FT-IMDR~eF@oMWRJao;++RFb1lBOZx)y`R&gX@+;gEhbe>5$a{)3k$oz*bX zyg9!9$X8bbnp48MGxnxC&=Ok17t*s~n944;E*LWUUij9~*;!XS4CkxgorSW+G2w8? zdndw|h;`NV)r1N!q#wG?gz|xa!`o)VSZlhrcWt>gW$TJzW!>jODoZOq&I5;kjEAb9P%;U6Kjs5xR$bKhY%Ags0 zsU{@phWtE5LCWI}v42)ppY|gzo6OPfW+mmHDk3_)xLyZ3s2zrXJu9P=gMln zHYr~Y-igDs;oGPivupS^dCR3sw;Fx~;C)|}okeaD+uodB3UY1W1na6-L~|sOc$yMi zj9YJ$zqFKkv4JHRTvjoFE(bdm&#s@QM1teMe8bX>OSTmR%$i5tVc)oE4}|>s(f-E^1oGhitRVClH2E_tLar)#cH1$F~c3v7_ z9Wuq*33u@B`$Hx=LJ8G6hHK+%W;!8@9aI>`Zs$jG+ZGMwI{z))ZNcBx|IiMsFeUU1 zf=qyvwVb4eZ`E%=hC!^#caJo@hkX?K0$2ENeokIsN;^NLC3fogMtcKWT6q_M zPCB26@h5j@&~T`gPC4p_u{xK6+WMNPn{ip#F>msECak!~Vs?FQ;l1{EuxhjQ-rQWs zEJLqtj_HN|l1neUKoi(#b(a8gRi#%ex1L1wCrcsz5JA-DmfHGNwLb7M-V95&c+vDL z`ZevW-&QItI<;u&-xyk)quf%^3%!PGTFwo4*@BhytemPP_g6R(F>YPI#>n-#!@?0* z@Tn%V^%?|)ywwkzXLg`YTg{enjR@D9uLlN5EDwGY`B7GLm3ynWl!f?ZWC-m3dTF?!?WRNWu8))>ZTIAAQywb9 zr}l1!nuq*YzVgvV^_p!ey!KN2+K2wNz!asY7J?U$I^$bDA^K(lZ#-g0$Zf>t*it>U zE^!uTgg?)tTL*(^8{dZlLrp!F;g^CEO2xBCGR~!gK0-?)PEIt9&B8|klvl}eVq0Bh zCDsxO!Wn$)U|eW3xNe$r(>&l%dUqtI>4dvrO-9v#>W9(v*BY&+sQQ47z{5Fl4Yz7n z`4n-h!G<1n#Usuelq?PVySUu2c zDsY}atC^p*{iXD*lvny-2`g1A+IF~Fa`2adwGcSjp+fd{EV{yvwj0^79ypfSQes3t zU+1K97p1SRwz^@2?6QTy$i%|=^{lb~)Lc$$YCl*n)jRtyY0P8gW5+1x*fhVm-nrF8 zD~ZK$Go=E>VH>;4CPR4g#}V;?T_wR;oUl}c2exmi&Ky?_`#_i}8x-D8+K2mVjk zup=W0YeZYvL-kd6Dy|kGbMwn;{uny%+?Lv_hHGE2YG^E_5?P#eS(yAav>}#4+|c@< zj9sOMP<2NV=gn)fuD{uYpC+^>lCKq$;dTU%t+gtI%q`ug`7K{{msSHp>|rVzVsFS( ze!7_@SvkV=u^wisaV@xS0XKV)mddv`f6?i1ePOJ_B00&6ObnTF?n(5zUc7X}ZtC*Z z5^*tbY~06PA>&AKm&&-lzP`AA$w*pU>~CcnN>$bSKt`=M+v!SC{4X}$4e5*F%HjfFX!}+HKpbd% zl%>yG1z^{2=vl4l2N@JwtJhsYG)CXkS zzzV{@VMwlou;83Fh4Uwmh1TQZWp|C~qf1rhYA8h((2@lMmMk@dITd}RzXR4aWDB>7 z)V(;fS{Iu^7#s8OhRO{1v9>-IY6QmD8cH=-1Ho!&H548g{YNzI2^wrDsne({LpRRE zp;J!F3+e;~e6beN8sKV+za*w}OEXk;G0|B)(`(*wbLMAYT!I)ZHE^zSnq>XyOx%p) zm}8(WLTbYnl>yu15s$+89#onaSTc&I)mv=O7a{8TMUWGx3~f{#I}L;vESTC*&*i3i zZKu9gw^eL{QAS8f9~ud9f*#`HStWg8OQjoIm3sP_4h0O(&cVp^1`DQ*?^$?N$HJ;l zo2%?~^?9c2YKQE;48~t&tct^db!YpK&;F&6yG}I!&BBxbN>#F)#8y{DiM5o1a2DUj z?-8-|rf8)umns1LcVBKh$?>|OSi}6HkA8!?y}`oX(z&myei&qY|J-V%mic7wMBZH%1s zK#EbLflzMn&RQx^Lr76QS;m`sZ)lOYCSlG9q;D6W?Od79! zUNP#5z?lVfMTjq)c{`v|M+waZ(|tM{`q^RwbsZfl^u z=!G~C1HbLdlt?FFFPWs=ev3-H{dw@p=QEt^pGqT?5SpZwp$+si{f>Yy3=-(d5GBOm zsxGTzyts^>U!(WN;t#o~sJA|Eb;V#Up~XzY;twlOQ$%gS6u-swT-K)!vP@?UVFE|pI~Wp-e5G?91fJMF8zTb;_ou?+7A6^d94#DIPj3bt>J-FXMT!8cKY(IIRwO(!F zowC*NY0t~7htW)(0iw1oPfM+{ezL0-$eE(SvcCNj_4ZG&tcP1I_121{!k;;#sjBBon;oVY~Rd6Bou7ttMHOT0%Rhf$R zd&K*-rIAhFNtYc z2|w))uIs+CSKRde@GpSnbe*_#mh4ygaAdLi*N69z#ZT9&s<^>7y8Tqo^q8Gc`5MwG z3ct1O`LhQuuQ9Lvd$NzJ@OPdac2Xe+O@@buu1xv8ZhfObI@4pBSK)9Uad6|+Ow?zpF6qo}7>uSx zMZ6BejNW)z?MgfZ^L4!zzttgks;3UOe(LMYI6Cvm{ZZOT@2=ta|3%z;KsB{>YoIC! zh!hb8q^cZ66hTBfAtEX&2r4#;AaF2BkwAommM92_2(bc635bY|CcTCpsR2Pk4?Wa` z7Sc%acEEG)`R_gVy)j-HZ;XtLz1P}1JA3Up=lbS1zm;$jiQwkr*V0sL0=ZrnH5|Z9 z*d!v>OzvGQ;vK z^&!2?^W0IL{Y!RbLtEp>uRW(B@09m3GQr3z>Wyp<*pmecF=2&C`-#6iB;EYl9Lf3y z6Dh@_vVXESnS*h%L5p`aA~$FqjRiXYgf12MU2N*dL$1kb`ROYBti|(ILcr)-?fD_o zeXZ+|JHe*CDmEW~xvI)JH{GKPZvq-!l6U`X_RYKG!)uKujqNR+d5devn^wW^gKXf* z+VmR>wel5vvWEpnt9u5290oe$c|@@=9(5pU$4;f{XmV z&vUsnWH+5cZxkyU!v@Ciio7?S%?5DXNo~d zJW(tj!()B7V&`8B&z}1{4u`PL;oRpjJX&ED_`eyRJ$HG%y6e3c))}6QzZo8jkzv+< zF+5Nn!$VwWc($)IJQ=?k9##PF_(5(Rs*yyYYGUEW0SZ=PZ8Wc=`yQwWkOt zVJ1SfhnIkQ3Jmj#K}Qs1Egt34{ge1D^x?1|`y@zta8OXC<(3BA3~OwajzA{yKZ~Ac zdvgr7O-ZA&UOjyA@jY!waoex)dnZdFkwfEzd?0NEznmWXU3s;>SLYQK$tEu3of@6b zaQKLz8{#X^KFaZUaAn+%PhE~L{b*RB@9>gQ`?K}@(QwY3?U{M6$!D2Su=vv(``Ca} zy4Yu3p4hKp2n6>TwQdZze6jRu`FO9!8D4`&7jdn;3yGQauUve0z1*W)qn6h^*UoF^ z#JdMnb}7CG-hEkK<;hZUWR@$(F55f_#7Mxz^`X2k;^X?#d@l0x$MjW$Tb;b>**dk8 zt+E((R7~-mTW-CH&ARfy^*6hCW#*qMEHhC-$GJ>{Y5gfj5o8KV!ki1>r;95Z$lM|~ zCfpjq0|qB}z+jcD|x` z{Lss}%rCv%I zoj|SZU7EGH-SlY8B_h&F|Lx-ns|)LPUzP`C0e72DCQ@k(z4%MQYmo zCN=XOBB>;U?K0Cxc%;d6aIiTFAWfJ6Y0|jn4M-2_o#XNvjYf+m>NweS8`Z^C7Y%Db zYvS&hcKW7{k?L~h=D6rbKVz@-8$kUP?*b&*{=#Pps~cuBb?8+0v-U~7vn1%5<6LgQGTb`AK7q#* zzE&iJu4{bK|C7`=2*+lH9oOkye4su5Gi;8PUaQQI`{a3zgIpC z`+Ivu)HDa}EjV?lG;O0I>wz?Ux#!a1e=c5Fx!{C_)1R_HH8gK53630~GzJ?FQ0{Hj zh-QJ_+|E%SnAiTzG|VXvfl8IUgKjsn(Q^%gu~(5b&zW2lbCF1|df8+pdj;#&L{VRS zF}}Vle+7kqjrGjJ`d>6|;wp-Wt9@P@-$zAS_+Yr!a*hc!H=Wobc?f!Yod~szMGHA89E5$)ARShB zAA8{Q+umJNw{HDWU~%ElNr2A<^tbCW^8cm?&TIx0!353(q7aJG7)KNyb49s~<-Vme zd7I+Sv$;uY0b{w1E6ZcOHLrt%+|jd**?`dA1I$y-tT4uUPZbeh9vZz3V|SKjfnJ~^ zzyr|OZwO~f*h+Y*(h4sZmPest(JMzHV&G2}qX0+kG{#bUjOTe&#D7R^OdRw4^D`M^ z%ZoM$a_?H+4e9PnCN}@Z!QT)cbx3Q>IFyxUC%nNMtpPQ(6pxz$wz=V-JKz0_hQeNF z&Hq;p7UlCL8?nZ@X|-q%*ibNLf^#!ljYrydXEX+r-HXB9X$^m~gtbG?s}_I+`M_ae z51T8Bd9IBH>$>dT?|=SNS#5pv%-mZ*tKOpp2#`Uqa_8Ox!r#tYO>=L{Kc3&V^~X{? zAPiqWk*5^@M~eJD_$}yFua^HR2A|xRPAd;y1qJqMmCP;YL6&5bF(8*_V{qWXb)lSs zVs=ed=wL{2cK*95I*FGSrwIfbtCN^}(=!y^R~k2ZCob3(Y-}*A^LcQl3&09axWv zAV>D+p~Naz9>eE3s8w1V-QN?aiFEUHA3OmFe`u7N)Q5m49?3~BH@I74j6&<~L&{lB z?-u7eyMBIN=wox|C>o2)yzlaDPxhlwfX3Am5|CC^=6rlgFJs3j4VKXt3E)z%#Xbk_ zR5G?4IRxwx)v`&{>=mXNt#6!Ko=jK{aNr7O6UERbsT9P1?(}wE{jiiqFow$+mtT_B$L!Onjc}9&pjhlzX*5P?2 zo}4@70%C3r?!$X!>_0rCCmh}%j9XE_F3l3U1)Bh2Nic5X+W1-NdBcyhyes=COvDn@ zuYGLwi*g$Lr55|!z@-B`_CfL?C6Z0x&g4_Xq6MFsq_)*qTco`+6784_`M$F zOTpc^jP3f#ifiBG4kvGUJ>B%Qlm7jd^TgUQi}c^}1Iw%p`GKEWIzY6<{+}Crn7P&oc;HB;m#`Hw?smn>XnNW?y^j`if399al4$U{jR)JLDyYpsb~)z9uF2`1kHH7zpmQw5rBm z22xH>nAu;^WWI739EhPTgSjwT{L-2c*9*nbq7fF?jKFyO^72~Vii&PoEN6U$qJH`I zZQ?86VKbWVO}iH`(J;N%#pOAK8mE`?_zXX=NNwGN_SXfUMaG^)FTEz+#<}vuUNZ%0 z`uyn)1s0}i4~f3n`p_>Aj{(@q~FY|O-AM%NH+#$6LmQMw+b;Ty;1Vpl=SwF7_C$PXLiz>dJ9!Udr>eLA67?g&raRHotB1*Fuj& z|GCg3aK%z%`2#5>4hXb>KDwfXw-%>)%~AsfK>Gk5wAbN5`<36&{=$FcrSeojwEurC z*=9RTW(!L10!k^Ehos~m;6NuQ(fU`~{|0DA_ReTB13p0jVKkt0o15+Z6M3>RXXUlC zXy?cOaRP~pA1XU)7GrRWNDAI9X&k^E%zE-=>7#hiupwiA@@#y3AlIYuu;-?2^FOw( zIlqTwemHbEY^TWiEl`AW+{ksblajmqQx&m{2F|Xia zdSD6oaJbx*mFhk4_JWA`Lhq{ym)%|RN4}SwO?X^u?Sr3~n|&XxzwfQ&OZ|O&#vlK= zgP+YOoQOUwxib;HDo;w=Nyv%p(`z$3kku~cJ}K+DQ_QL{DQDs?Q5o_F?Cf#K9}zC# zg0|vT_A`gJbA`V!S}%96ke=PNW9uvLVPzL_aEmRdZpD`amg4tA@74Hv)1Zc+;$V@u zU40b!;Mvi6m*NlYvAda|Uv|=7O0@^VR*OvWlFJ?}jLql2?#l7XUChyy-*-g!$+EKIrFxQiYn4>jN+o!^IZwfF1aOZob8qy}(O|Ir^6S z&G`Nv(wIM=@y4wQ6cvWP)92k<=RxJMWdERuzbo3#GTQ%k&w0nirO@UEpIam zl>8iF>CTRXG;n4!x!y+0q`u|1fynI(?I#YrMtSO+y+IWkyD>=);4W0JeYJqwq_EDW zh)!+m=1)gm0 zc~^2u?%UfV`6hY;b@z&^A;pxn(E^A>HXgew?_99vj$b&y&1DdhmCTV#aj#MHy>G`= zz>G#K&dwz?grDmWoLVoeC9Nkf7EwC_)ssi6VG>R0T1pF>?loV2%L@F0i?PRse-1^pLb6*Sv7Y$rnpJ2Oz@Le}Y0h>;sS9x5;fE6N1FJhabz$Nf4FXrwM>I0tpuFfHJGPf7*7YlDh)QXb3eWX2OCm7( z76_e9sC#ttLMBlTiNDSrnB{ga*cAds%I(3Xb6yos+C9ygY{muP8~b|OdleJ%Ah43a zPv0QbGgJ(VRgY`}jM$!MC_IZ1ib(jjw|Mbv5o~`vU?(O!TEzL3x7t4uwthB{@u|D^ zHkFBIvz@`Nu&r`gfRR-5tmSd-Mf)fHpeHQn=Y$5J?uFHfy?K<|r)R&Ulz{RSImBpm zyuvA1^!nRQtj41C&GZ-gr5v`#Xy%gSUEWt`&ZpdI(>y3^pQ_N^lG(pc{(gOM>Y2ne z`Oku+Lq*go{ieO7L!o=8(AOvBUDMBR6FV0e!*?aruHU3pUhsp!jk^)ruvtH$2s>{p zAuZA&Sj^JM1T5w|Rlm3dGuEu%RLBJOLO6-a?q9*ALoQruH@9=8X}9H-m~jZ6dVW@p-Q>lNGk!J9UOaDoy$i) zlRhm-t}h=r;zkw^Qw?ZcePxKNcoLY)8>|tiByCiYvVXC$PDK*)P08^oXUZz*`0on> zzc+W#0C?hRN?p@PC&nh)t=7Z|zF2V}g02s-F;w~4lZ(GE_2>m()|vFrf?4(D_D9^Z z#KWfj*DqD@#Qm>J5k~#+`@I|M4oJp*Q@X*sl>OhAiZVwYJl4zYml_J2B^>iz$Ywm- z{WyP(seM&;&D}WA-55p`{3_IQDRPZTB{>7#a}|shPjOAp&^M0_`l00C(~Gp*ip6W6 zM8!_P-Mjv8y8Bze-Rq8LJaGjaUcZ5lq<{x}-sjo*R?x@Q4KKaLC420{7MBl<31c%! zUM{93Gnha&Q5MDhKbN1N7T%iGKX6+Z9bO^BZB6XJP~<=JJq+*S_pj+2vNQSvTIprD%CA*j3Ir?+`I zDb>6CoLYYmo@7KXAl{b`9Q2YVK!}I0kadYI}r-J_D)6J<6Jb#;}&^??vuJ}Cxa=Q z2x%K9XPJqvL!iHL!Z*^3n|GYwM!L2gkkY2zwB>DPfnuNE1z)k^I_sCBBA_Ycq@G0#|^)dpQJp;(CAf(ak&0Z{FF# zADr8Qdg8ju)ycxm4+Qj-Qxt{+uCAYqqkj75h(@}`P>psrTc~N}wv^PppHwtA=WQ0? zcJ6GxmkG{o=|NRc!7;8Ji<}fF<0j>VjiH1=zYT2lv^t#hn#zB(f&)Wgd#nK563z>3 zIU7#-u`4gy^DmoH^fuE{YgYEtrax16{4Xa-(nhXRMk;&83cTxPm$Rey zU2n$faAMbRla6w%^Xss{b3hKj1VF^YK3*Hs8zYXK9Gks;p&fs??{k&!u>(`a+wsNy zo==FxX)ARAwFaZua}|T(bhaG35rD|4#3;smut6p&ya)rCT0a70)sm+`ZIShTz%fK{ z{RKCUqe(2^j|qUdQDo!}zbNY8f$cwu@;T44`2?!Vk521*W-FH_8rQ1b_lJD)%RqGx zunIHY`c?C3%ZmaUN{R18LQ*s?FlZL>$J@*j(bS85P~*eiq6wd($AYeo3eN*W)NycR z;q}0_TQRF3pZmv22VwV@ymQ|t_BWR_mNH@Yc{7R}Z$>$|KBMR*GpwG5zUrT@W&?;9 zx-zXYzcS3xw7+r}rCgLCL*YT+>xA}YsN~opWtdG;STPs&91I&WYbopHwsj3@>ReU# z$`B-arT}Qz^GKJXb6>+{&$AiP9pTNB8zz}--X95x=?q2i+zKKP2?5+n8o#E}nA@zU zm(=uZzMnVoIzeP;ik6wnMGY;@J`^L6KlJdJT zh&yxGA*K>e3-wVCQ$lhtdX$|coK(SHoBM1}?w{BGSX=t9XhFrn7^;B)tN8tfmF?h5 zRgXStRsRSM`J%bEJM-UQrBN=QcODn&xVG4LbCk*;G)R1%aFh!*=ePi-#Qg)zFmJ-@ ztVXY`!v)7voQykXp{!&HBle7x#Av8cR;XxY?Y5IehrDl<>H*tb#gGAmj=+*NkA64|{@ZynwiD`l95R>V|IXMal)IeIU6^@F=t=A?0Ce&L1a z$Wk&(mCd$G3m5&>GT(m^h?nd~vGfNim>)%d7(Iaa-K(4!>b9P&6YTE7W?9FTn*J* zyJ>7-H>atzkhH%Yf9NF7!_{{4Df8Kf{dEXJbWL^0x(B0SFj=d0+J(Mg(XK^bXlavY zEVP&-0*sAd5@OlW;`sNW0GLM{4U#omo7?_}pKd%=OBnvD7r}b(CFR4GtrX{IW9mJ$ zZfSLvAVqTp0X*&S4nIKb&#R}l^!8DK6>F1x||1 zJWq#htGNwZb6{wpQn- znr;)>dmw?3ZU+qx; z^$yLu3Ak=V9 znm-7=01u1~nyoWcf&ezW9NntBvJJ3d-N>!5+o^XD#t zyXa8m%RRBqb4`cibBO1575)NMKW3kO?-IIA-{)j#e^K>222}ELvBuNsxR{yjd}h%y z3yaU#cK#VA8VDeHT z!6;hN+i^a2684b`v9wWd8j=pE5os;s6b`NV@lTeeR=9v`^(soD^K4e`>4{ZU*{u5 zWz`SJUmk)^n*!}WU%p4qP<8EPuXR~faB{GGF1xbvMZ2Vnyx!_&fhg=b#!N5i7s(i0 zWK44WU*>nimqEH;hT2Nf6*dz8V|v%CqCXvL{So}m4Ycd}|C0De7vrLeDOptS^65p| zH?+$ce6b6AZq1z{r@~AAhkP$?B>y1n-$|XJH;%T;8`s~ab5nQvJgmE#@v69hmHbQI zy89I|Zw8~a3p((tiqHop>9!-yM>lZ4-a`GZL3|`weSYOCFFbvd2z3!0h`P`zJ`m+! za-(ZNN!WVj-Mk7sCQyRr{5vrr*Mo-YgS{KcyGH0ef5M+a&#o;jSPa6ND8SE4DRcY~ z$@6Co&CeheY?0e#^LZyv_8*OiU?mp> z|GXUh<~lL9kRn1&(+r-`44!9JmMF0!Skn{6h68c5H0~v=F?o#D!R;CAL~}wHO^fdP z-e%K@N@=HCGNFg zI#oohFDo+NWMWnorl%s1zzZ_18>uaSM%L1sB|HW- z&|}AVsp%c{ib`nLMZ!@1O1qD>N?UjL-mhtY%DO5}ECyCK`@VRj>8kkIk*r=@&;hB; zeQM{$ITwDfGX8s84B7C?4Qgp!#ocCn%yr>2EQ|Rn8m+sa%=g9ljdNbWXQ)w`is=~0 zufWk?iKD9>?o;rM9QT3M`Lv+$lbXifHMSJ4O#(v-Be zpYUwPu)@4J$uK4Ch~?;(4;-C&I>iHQ z@~~@lld1=`eA8#h{ts&b77?Fy0&b=mmUp#pw}>L=Tr}0#!Qbh0SIA_l>$|0@yrb;( z?-el@pm*+dxn@2IJ^#qPXN!<+ipsOYC71(vy)Ou?c}4EkMdP>c#=^q05L<)uXHE`s%`wTiSBV>Yq6pJ=PGw*gC5bAz%|H;KiL(y8-(SKG7i^^^zsiz_Dd4KOZyV+!(SD487OG(@3m91lRpTV z^{aCnVN)8g0?D@GtkQF1$9licN>q?J@Co#`bD0sRZhebZ`J8H*gBAn18?_3#q6J+w zW@0XTtmK>>Jyq2#=)G^RP}{RTGRNVtO7%;u+*P`&mjS_HkI~La=jfsclvf zG+2x>xi}~88Jww?AS6Noz=RwiRD4%(hMV_{@V*oM%&J7Kds6* zHHzAVK=A4c9_TbJ;dMUab$+?}6M!f|kmSSD84jo(V)9ahcO+(;m_g5RC;Kv!*}2G> zUbz+@OuU^}i}k;Qj`2%;DwV^_ua~d>W}Yj?_y;0{JEI0NGP+IwH|BXD!mc8M)pl9| z7pI6)oMGl&{I!$~l77u2BLWW|*x;T?i!T7?6)01f{{Y8maTLT(REmA%XMcO2By2Be z9YW4qcvdzTyUI@D>b-8w+E;m-$<4TbB4_f;^ zn_;BffIzg77bnV$+q6a>M34rOFLM^`ht^i$?5~izr($@2P}pGEDb%fvt~)1((YQH`c;Rl zR67w`xTfs&=j@8N288S@H#?2B(0d??1L%$i?K67V zZ}+17eWrxbEF82qC9|l#?1{eyix}6SbPu9 zpFUS1ga@p)8nC!57cTpyiTjPz!X2IJF>V?L^HHmI$0^LGSc%}v7TA0&_U8=o3KfG= zX8vR#sqq{?ckUXzFx!D#6vte~Y6Y{3F%)1i6U_=NDikKgW(@e_hGZfyt4l^+26&)4 zpspYzdv4D6Pz=f?LCf2Lazd;w*w-%nReQIw_lhdiPA=zcqNnUYr9xMWcHjQHp_V~2 z_fgh&J94I;l-cOo+OeQCGIJ z3I^))a<%-_iN|6oPnN=SBc3uvT?}_qJF~DkR;|9n=p;6bF;gmul(+l%2@}8;by40; zway05d0F|7_0-{aK{8i^=40Cm`t#d{E(EOVdu|t6D+Dc0NDhy!8 zklV;9r9;CfyWZX&H#Yetvtza!MW#rzR1=Q$KzYb|qlA#$^QgENRZQ{d@_q*V-r4&s z@Yq$Ln6qrsi1OeRK&*jM#(@b!DI{@&pTQjDT5BoO--)mEw||sTGJuMD7$!|Fdm2U^ zJyI9kUpI+_TSmlx@17|l`A@Dadd@!$ChtJ2E}vt!Wto44?;fqpyac1_+=$S0O$rtu zz9{`dNDry_)k46aiU*S?=cB!t)X)Ciew(nAB7Fr&w zHi%!}2pFO`zL3{#Uk}(Drs|hfwk1Em*Asf5eTnOu#w)*O62U@!Bb_727xDEa@kW|a zcU70`)K33ORJpSlYBauWBGOyvRfN&_KK!D8_*e=mo9pjq~#7=47Ky}6Fu{iXQrxx4OT5_t);gsOlAuT@$MFy}LXiBkdD zrE?_=a&>}`UEMKEoMY*Y4KBot2(ML)P{h#pw(A#4YiHf&14^UDWC2kS?u;Z3QB0ieeeRMkVR%a6t^^2hWfN1%z3-9QC<7>WoU*rqSW+{xC&kq7o3 zBKiExRwY_tSrf&AOD~w%dEO!%=#WiW z-kfVE8RZuhb8GwHvilnzpK+X-f^uNGaHkxzIcfAUIYO@ZvbTaEAy;WJ>uS~xl7U~A zi$)l%p6bn1wg24aJJ;j3<~vs_air*bD9==rfKi3&v%Hy~rU5GCKOfU;K2CK|U-4`iZn0tVFnohw_CntEOui3Hvd zY2VXdWe|8yY3{?VI1i=kZtk-l2ZA@9R}#yVK6zY>CQg&U(WG%y!#*I_NS2;k`6e-6 z*Nc+<(Tf7UmTwv=B}I~x-&*bKH<$$4^D8Gh^Je&~3u)@JXXMR#0Q*Xj6!4Abj>qeL zLVzzc-Taigto2&Ob?!y1@uG3u>qTu-vm?x@SuOj=LKElrm})+FoQAG6?h$8t;I&F% ztFf%~JiEzr-H;{nFEEXCZEO|hJES4c%6@aCXOp~GHad_TQ+97qXZyP41&BP`0hP0b zeN1;HfGN^hfWQDKTmH5Lha++;vXijvxd(ZWA*(bw zz?XTGV&^!fPKpRa9~~-$4UjHh;}ogGV_ zN-et{q^V-d`x+?<0%wJbckI?vKi$g2*B^L)DPkc=U;T8S2JZ`(t3&?Rv4AVWH!&GfjC$+75I9j1SI)-}e&)%)Po# z^Vq533p9VDK-n)&@{leo#ZLGv^Q(flv=fjBhLU~B5&jp8@fF>y0V-L*3{$?+QQE&J zxLq)KrUSBzdqR%=KxgKgLfFT+&(tS-rf>cVyQWaTMzv%(s1aYBx|KNpv-hi`g;&B7 z$fi;&tn{XwtF>v;Z6yVR+3VXC-{oC~SZv`94>c8TUzKwbcg-oQDllONNS~!-932Pce$;gJz-b5B5GE4GDhMe(RWj18y@@Kp7Av02jX34nBE1 zC}pfT=gh^7t#_klEQNV_%C@gnq=nGcs2#!vQ*^~$@|-CsBe!|zg=czbMXi*AL7ifI zD(6AVPrhEU+!!knxQRC)zNvZd+Mfw7NCD@D z+`c6vBXMl+Cf);k2bHyY7_o`RQXQ#tTC1XPLF`foUWSBK7cJ9U3n)Q}aJDXAWK@j6 zBXB|R$TEm(7>Y7QG=3S;mJ;P3E04Jm>1AlWR1B{*3_r2}!?$Wa^M~xcsT**1d$GiBz5AyPW8@^naM5=G6~HF32m%f> zTK=S{c|MK7eNrYF8rYdT2w}`G{S4wx5NOdmh-_|u!-4-2S!?OSN-@u@b^ zxHi{|Ucy=o_$1b_oHKD8-I*<7#)cZnd`Va|%2mn^n?c-!!>BUW-8}-`y|uOpyr#X zuJc8PZ3XB$IZ)c;*W^t9fyq9DveCBWa5tHT>uR;2^viM7{p!kdO8lM+)AIPnCEKAw zYUL#x%~>C_i9JjsQ-9~~#+atGbgS~B19w0ZpNveohk?i_34=R4Lo;~0y1;HII|aXL zR4eld-=b^b^;X`-%d+OxWxj~olR9kB9D z3@Qyo#cTz@@1JUMfBZxO<&}#; z0nve+#fE{gtmj}ab_wp*J}|R?lBDRql5K;UQ)18lLOnpUGRDu4Y3NiI${zw}Mh)~6 zk)jI~hQH7iKPrN+PecJfLuz`19W;1&$iC}WHOpeK$6=h@_mF&s+~?a{L8EO#=k_Oh z*hRDEl)JD0bc`A7>m%-w%LmT(tOXFXP;1mc!R&f8B|Yu7y6+<>NO^>~$#c*SU5iU) zO~IM4*|~Ryf&0HW?Xk-h5qxv@R(F(MbPj4qe)aSk*2ILuK5c2S5Ce zM|jYt1=8OR$%2NY9@v(t z9Jwk!i@t7j0SrfX7cgS7@4L(};+c-zN+!rWwbTYBKOATcr);On6h%x|_+u$~t2rKW zP6_&!H|9&rk<<^NsAz?9UBBVJ`_B}VT#2^xBWtUxMgCkAWZt#cuSSPjlpBiOu9NEr zzWhUspkxD2MAowJjUe}b#Or<3up!d!5;O_}UL$V>nHwTOqYpO0`Q-wh`d`&|>QG4P zn{tXy%olPn4ocG&tvI>EBI4BxQ#S&^=sqkk$e>UnSi* zKrM+f#g4D~j8>?*6Mn9~hIREu;ih17y-}u)tOy3xEKkU9Ndf3AUgT~B zX`aS=chuuBO~=rQzMsPqeYZIn>&@=uH}N{LwEPA7r+o~`+dgJhK2EvZFQ)l2peEZ4 zfRhLJnPk`)bLofX^Q18XJ-&$ z2nRAcLVdOr0V$pQ#9eqcAWy}YaRwt#S< zf|H9fXX6%|b+ckfGl;Ah@Kbk3c-yZf@RBZYDcc#P=4TL)xgQzjVw>+bM4&>uYml)c(q_Y~iL5sVV+l z2Wh!bj1jGo5a?(?Ys|j&aQmBUlwiVuVC9_-a~>sJjU1)C!h$3%&K%oaeHFJAen@bW z1h8|>hNHgas?f*%@n3Z8sNcejB`;18LhpWwf(>2L)Bir(_%@CFHR>^>Fmk$W+DzsaX@G-wZf6xHOPv0-fVSjm@0nBb^S0>*Hj)23+p)HcM7z zPC4skQdPp&_0k!%K4MAFP==s%e>QeJBx?Sbh6~9#P`%KqU$M>0i+ww!xrR24t6wE` zuls+c`#s8l2Za#Y(-#FtYz%wmR+D2V9uK>*T$76XkR|`K8bESmjU%PVg{1qe0Lp#f zy`UMI`hBJ%FrloGp!S>pw^|!q&6BtWNh5#ng#LVMn-TAX@1^F}?|V>qUlY}YN9l6T zg?0t>5YEU(;2mzclnyNu-+*84FHjWr&DC+s2sfxUHh2(MBDJOqe8#5wv*PZ5s0)+_ z?U3dRxqY{)3SrWm>J;^^O{9J2GSuPW-n(IzC$?2SQ372Jl6boPz;$0I?A{&HtjkEy z6#d|wLaDd=qIQ?5Max-H>O)Y_*dGF8Z}*C5W5PyzPE~t3acOV%K1+=rAI9ZSylnnd zDpCqL_VG#ZgDD$p|Ays`nbc86&KZSl!Ml+L$zlN9J$B6bc2&y6PXGhM1@1=r7i*jZ z$ZuT{KCe2o;^85o`huNbOLH70_lk`zxkw%!+7^gWpCv2ojPR~jRMd;9Mff8NMCvwq zUWV-0Y&%+hh(><$kXdbY#u%vqt~ z2|macp^&2nsUmcV!)9l<0S(|SJ^PwP3&!*gj!+rV@%-!c&h3L?VRueG#INJt*_!s} z4<$D9;$`<^OZ&~nTh@=+VW!EC<ZA0J|9(eAp|C}(}zpjr0 z6xcgU@}2k?2tI86d*en0|U%gR{lBqkjw*H!*Nv*7?L=czRSP3vc_ zjRac(JZ8Dpk#!yu9=lMaFE~w6L%GxK9&iABoqV0MV4McT*`aN3Hsb7D_TO>VOtTqv zr%=mF{FF@T>5s%cVjR;6Pa7#2u^*;Us(drRIp|QLJ_2-2FO^o z#5NmQVvpO?Ypb0;-EWY@As3{+jEy{mW+}Qf$%<9h{$t*+8_cST;ET+uQ0uqs`N#y< z!E`j&_~Z*KknKCZ*XEkKlmJwgoY>P^_Gt@@w}s>PN=ir8dSp+$9S_b6TqqKEF-0Fo z*Zp+cmzzI45qi@W2za#-U6wfj%-&>J)csSh{Dj({feLSi>wbP}ww1uW+(O9Nx+A~p zp1hMAw<-2O4N%>T+gcPS2{=hveqlypYIC;(2I1J!H<1XM5E;xBW{M0_gqe4LS(Ph6 zGVKDa^iAVRLX2xC1hxiu&8SRraPMXXS#NKJ$cmwjd!HVy?tSWsZ-zeVB`6y?#%#Cx zYo;`eYQZG3^u7w_x_N?jd==RFRUjlq<@)?9n3A>t;$LmV9k7u^){hc&A}fBZB)9}) zxW0XpRpOo)2+0JKjGcMnY^1vt~+{U+KRW~ixb^h1ZXh5o7Xj%mD!wE+h;+H;v6LVsFeN9 zY-FQ>bT`Z?xNjAT44gIFX}_h?3atJOT(nMP!n_jM;|1zR&B+eIF@+>HK*F&^H3JBo#_4v}r>n5<(FL zz>VMFi@d=H+_*c41b!;A2-WR_4MZ>W>66bM$a0bds6|Dxy&ax`PUQaJy?y!sCV_o8 zE`y|OZ%$GHCz1PvO|auywepWlFsRtKAc{G{VX7J`KHYcRMaTQ-NFV#V`9!_PJ6ohW zH`mU+S^rdA9&HcKV}~u$lDlZT-cW$cNN+#?8QIe)*pJ?7lnJO{KKbpgMcu zq}MYl15#-H(VTo{P4Z;U_GbDXi`IFxW6jU~`T%8M0#Ni~qPxrl0_BeeF5Xo!CnHur zbTb)M!SQ9U>Pk5$a~y&W_gHz?y|ij!Aj}af$I~FQuFwzy%xhPHHMW(N`AdkrdTS$BrGZx+b)-%mu)kRhUsw z7-xCjxh+p_IX-W0bs-)$`P#o_kLSWNqJ?oAiui0a>G1~-0>?FEc-P?}0z1p(Ffo{s z7O##%%%l3H0y~S{57fhoBJ5E8Rw(JVJ^iRmjHH-&(WB{ogrrPdks#~n@+y^gNqrwj zdi%2Gi~0b_-iLwD`wOd^1&cg+3nYw?#@Z_~BxfUB$z4FrQR7b1ljbd)aUgFyBgT|M zN1pM62;p$bWm=E5oWlu2c@>pwzVNHr6Yi8x4$aHmsD6chcSfJ#OTtnC+z6oJXhFYQ zoOvw+@4-xQpu6zb3IJX^fO6}3kEQ6Zg~5oGqnGRpTCern7br9gc)j>p!i@X+BJTOu zLc+e)6A{Vr&+P8$+H5E!rTCQj>oYE|Pu^jtZ?={>@>wwnYtABNp*=)RD2 z1{NY5o8umeg7hCWIjrDp1)H)92~ck(@{vv2WcdKeueLzQZN!fhJ?Fh1XSR0gIi5(~ zJrM4yXMJL3C%^k?EBXa*j>zbZnC>w>CA0IIa#NahV{1wi-v-%xE3;JGgkeNVp}0T@cM9BpXm!Pul3Z`$U!6N%XkRXz+Ic=C>lmXmM* z{?U^6HT&t*_94RVIk6E0UDhMcyi8y5&Hw0HnGqCZqS& zeQqKYQ7rm8hcr~F2s}(9GjgwsZt zN!u%fi@P@$UR9J1ikMZeYc8#Nx4n`C;%%QC)4~U&^s+DdVltez3h!LD|1;on?)Ch%MpP;J$ozUcJx%)Xqg^b03M{2DF_cr z!|n9J=?17N1Dj?tD!FQ9`)#VqU%c79urvY>3_@SaiIiP@vd9;&6>$BgU%)Y-@5L4% zLJIKlR}Tw4+I%YW$EMBYLBkg|ndF?&-MK~M)UO|Vc@1Ya8UC4>>X+D{Y$W;olE(3q zn>3UV5>@+-pZlZ`+$@Tx?{quM18#hd08AU%w?+A}?F$LuldIlt3b`GX{G5MH=$djG z|H9HErOk8CC&K%@cfM+0!$<%}^T1j1o3KePLX;<|%~2PL*(S4dozA>C6)rV=V4cns z_TFi>z+5{kzX9jMlC?wcoc_&k&ejaaKiu~l=iQgz?C=}s;k^GF&ikI=sG$Kcpb>8j zIne}kHFh#DZZZ#sq^JRq=thJ%<^Yb=^r$F9JGkEp?q*F7t}B-t+GC_kHY9v6pwd^N zXA@GRfgGC77`O#q8$<|WVE}-%H5`MIHuv9AC*O2*IeSgcr%4sT7=CRHtVZxQ!*V0+ zE{BX=&mSw^4a^t=PXW7j(11JdFm2sVxvZR>}OG=W5Mu#vA}WP8cOkVxA#1H zhfGHt)h@M>+w}(b1tF;3MFVBAXW_PLSz!p_*>9gF6hA1BH`0=uO3Bimr(dJ8xT#4_ zPjF-VtMoGzN9{Lt#7DwQyaM?#7q{|ZpuyY&DxZ`rPKhaux>b)>r*( zx6#i#pIGcrdtz~51jU^ViXV*)}*v20sHYr3;#KT_@=a-pstIU?lKL++i9gRk|#7(?V{YJWqQGd>#|(>PmF^Y z>{#|%>ca&Od$N~9Qvvr(34z!JN)LLHD#$%!jd|m$_2XGCa8s}ay{7VB8LU(A7=MK> znO>pkvJHj-tm>1ztUBYF9UO=5yUEpfh(&A_!)^z@kqs|MWsdZd@;a)v^G6uS?VIyT zMT{+axEut-cgs}cOo$}`|%7R|2#muzs$^Z^bG-99x+g{ zYl#2KLiZhx(EeDv;n^nat(O;RYMXlwxQg9{hCRP`_V_@p7QVKx7BsZx&xVHmYG~@W zT6POm7qtzjk0`!oV}4OLxV-Bs)pwcC% z;&{#Yu@r^M*&Mtx{$0AXs^=)e2=QcYx@kUX_qXc8vH3RR&#Gysb~fvUnNL&_ZeAe- zjh4OCl*#$R0xd1_t{VF2v>Qs~& z!8|pl6)x=+AMMEf#xnBBY_N%+ zylR9UZGvhRuI*kBCPq~BfuE)oJw+2Lc%IuJ^jD~Xs^Ntb#g2_SJHBhOr>N9A<>WVI zZ!P!2W!=WR&bQ1WYR`E^*+I$j`S_*E(BuQ#@2Qv2x4vV_`_Fs`zqZ7s29hv_hkfeA zc5VlbQWF-IQllejEs;}WPYTkGD^Xzy5i-kLLJ^wK0GP0i%~Kw}MD58{pK-~gbw!i7 zjFyB7XO>5o&JzZ{!DoypCN$LmK97Jtk!yKR9tn_iPnDP-?=f7Hb&F(7$=|W0(pxle zu-$8U?5@L8hddr5F-(-{<4dr+o=`iCRDS?V%8_r^sh^EnDsQ@J#OpAtX=_x6ZF{ zZ1d$?fm~k-0;VFfQ@`t0H_?FvL(2OPU%vCSzZ7&SmfofGd>y~_t*#zDo-OF$N_Y00 z_1`cTHZ(qbwPE;{-$aUsOJ`IB`3>rpO7<2tI}41%K%y@<-NP7nQak937ad9Iy+QBL zX(6$_-ACUCvbEpk6g#-R^eU9&f>OEV8RXj*he`N8k`@V%3nK=3i-MMfd!Kjn7MjU^ z#sj2tOc!RxtHis)HS>emwsHxmZDgBxtiF*AnjeyLHGCc6ni3;A?GP;af+8E1vyj&b zwf5k%b->xlPUt%d`g&rqP?4lIctnO2Uue^dB=;0y%TCi87y0M(+IOt@C+)ifiKp%J z{1XJ6jZc+4Io>0?R^buorYzZ|nEs;uYV>Z>PXpaF9`(T6+57s8R41@Vo8Jfq+pvbR zUm|UEIOAb{Gyf&&^%|Xe&cLPHX>nBPEO|5drT zIfQtb>p#b~4|>eE%Y=6KFFcZBegL+Yt?up`9;P=?p}ba?ae|{mXH0fA;~kUmrmBu?Nw{hni;GDIjq3d7(~WYT3^h9LLmy=~o)a1D zR8jp4T18U@p=kAhc?BQEiPOFxsZIGCTQ`CUM#Oa7z;s20O=w~Prum!77ViKT6&rW# zpsFAAjh?Re!*UezfG(X&SqD}i(52dpF6Flonv&>LD2N`Q@du&X;g4y0Q*k&Pa12Ze zHRVB+N1*I#Rfm0rDVaDYzZXP*P98BMZkY}qdDH)E@`~9lV_o^*Ig3@)e|mH&y=SoXg|>pEgZLf05fw4Fi{C%Fe!ISa z6d3Mx#7y+J6D=!U2^ZHoCXd7D|MZh)M)OHaK6 zK1}?9a{`%pg^eIHZ!Q2{OyL&|!KQ#&+4uA<=f3GPmxi8pkEKg!i2FrnKH4-np6e<1jv*d+3rTl9 z60GAYzt-`i&^o@Xig)Q-&JXY*5yOl@Q+NdN5ziZgT<9s9M)4z{ZQ}oo%(K5d=m+|= zD@762yWN)Nj(#}V+f~`r)2=5syjfDe?I~$`f=ntb7)2R+`0FLbos=ZjoYvf_&0gmej z6?dC$`C$76_PVR;3c^z>Zf#f_5-sj_(KB+MWOff5@U{xcc>8rnpLI`XZL?0ktJ8SM zd;SfSOX=A5Jk&yp{RO5+X`No`=N~M30H6JZiO)`5iO-&II03hjj2p#o4psgL2qR>N zNL*GzHUTd49mfGqduswhTYCY_CBsEfdN#NW-eI^0dMU3b+i+1IWBH5>=px{m%cla| zB^E&_z-n}W4#Nf!)T2beCxNr?53|1F@dYlBnixT^S<@A&c?b9@I*zXhwFd1nR1&1< zx;-u$TvfGR@C}XH2HXtAKC(ggPd~#)OETG|8NXh@P=`_I5A!>^zL5PFxDL>OB!($P zdmy*qcLSI=em*l{Z=&+XFw;pZM_~qB4pZ1;XW9L>r06Z`xa;yq-`xF3Nx&ZgXYxl( zO0O*aPVdnrP!9xWsGPl)8r^Px8-603jKm$rYeKcZ-k|nZG-`R2ThB|6pK_BG+vgh$ z69Z&8SSX$i7-NvDD#49JDab@b?E*Ftv796wMt1OkBjU)>PBX-1oAnfR+V^t^Je*z) zt|LZ{Qo2fW$$k7b$&_$su8idzzW~T4eXG5AvVKKHu6DR)F>ke4`Uc}#5IU{q;;ROC z#9tjCeHYLq6p9ykjBF#9d*5s`zD4J_C`etwaWR?hWbre{6!$;nn8K866RXAMozC%t z3i*TyP$7SvSs|anv8tJ@^uYUGt-24<>e`F7Ct`U2_Xep_=EoX{c__HOEW&=_gAT{s z?o_#fB7HG>kv^O|+p%Z=zz3JyWT-7dKwC8aYzw26Z9!^ZNARtE;J5h`#9L4+1)l60 z4{FE$tw>?M;T%Car?zSzKQ2*U?m8*wJ#=X1FSjix5%?FlNGK|qdSO5_rxtJ)=s=tW zTo7l$E+%Ke(^Z@W;jm(U9O#f7s6%jEd^pe{J7X6N#l9=V`R7A zdt#x)0s4?~gI#wG@w%YG;Hp8i4*SZ)CO~`z9^psoV6m~#p+ocznb?L)2>9AEjAubd^|@&lNbColsV1?7 z(G*&%n_|#g2AQCCwKv`)T(=H}jD-#zqNQb!pecIe8BKv*o?1R31&AOn8iCdzLai~v zY>hX6Z;b;g>$fM^OiMj1%G|I$K?giHdu~r?n`F(>do;wJrRNXT&(No8)9R_3nXCtq zM##ph$6WyFV0-AWX!gP(Yjuzgj-{uA!H~-)xK!<1LOfX?0%#!i0UC(6PoI9Elj7XI zy>jLsA2n7nk&0D6%440-<|h>^EE5Y#?{~%)i5mgph=l*g(SeS(rPf*Bo-4R$02*W` z)F2T*hllLS;US3?r+@_a2_EZsa2KJ%GNHn(74}?Ym)Axl@L}2|H@XrmHaEweNo!s z=E$$X%}_4MoGsj(O~+NFWcm2$J3uv}4pEKt1FDfYCe?_->IKGB3t6SWUt%!ou8@-s z6tnrD!?B#;DraC%NB2RbCv!PCG^PS1#RO7NR_{%MM=sy156pl6&{f=kx0rCKtE>1S z<81)0!+t2+xvrnF(my94sBN%=cdu?`Nrj4XakfbJM1Ku zo(lMj03lP9Do0rQ52Ggm$SOsCw865w!X)@=1U~3+Y%;jY1$?z-##fufA=Cl@$xY&& zcS)v3!Cb?I zk-gq07V@kL;<#Z{@GShO^zM!8o0bX!7NIvz2Rt_?)+i#}sZ*maeV%7BQpsIw4fVu9 z0xi!i5qW~nY{g(Afjdp9LyfR+5?54(8jyhNLx*`-9zHZkBTmxOh%}hdJQ@zF1i#BG zRc+XAw&6)g82@brTCA>7Xw0oinN$>)XMeid#1%DO_93W}jXiRw66G*d$%Ziujk)P+ zF5hHYsJ(RjkC)EanRcUfH8I&ieD&Yq8%nh_Emfh`-g*Pe_vVZ5F@VEVj*1JmB*@bKh|kuR{3v23ksa zU^`(hn3mI!F1Z}d5?;vCWj38PWxWqR-94)@-#i12QHnIg!3d&pHSpm{_~EUvW9 zO)c9=#IC1YL>{y4n!_Wt8G*t~?hDe$1KiGCfJjZmiT8a)dT@ZgGVZgvg?G5m=pJt3 z#-+#Ywrx57P|Y%TDZ2Enr9X=*IP4leXr_7^Dz^{CCEr_o)g(DvkX{<( zN$1yCSP$`QnEZ5TA$|=l+?%A0^M<Y#9dkLopKfKQgJ7ECgEh&`;SCXCoZ2fA(5juZ`=UB9VBw01F}YMGan+JenbWpAu= z{VI0Sl_ZxLnYwY*t_0XZJxPWO<1xKzb+DhW&qdUA7ca`)Q+CJOCwx>-2N6^cL$Fq* zK0uZAd?a0aCV9WxN6Y1HSRX)6`Fvwg4Nb138d|nb?aGNh?`6k{Y5p;pchS69(?qC7 zG&=h=Aip5?DiFQFnfUI>8)pL-C(PR7moa4bXvMCi-CTXwvFESN3}HNMZKik#84yNp zp%`G~@B*PZN!WIKxOO&#kt5nKlM^+GnE)UMPlSLQ@L88v zG%4i5Y!|7m!J72(?&QNeSzC}rihYrff+r4qPRY1KX`dSeF?arud;o5j%nEKJ}Q(@_8V zMm4udMnze>&C|=rKIA?W`qb{a8|3xp~wc+2S%-n55m_f`_Gb2^;um| zuD@s+y~||~-qfHt`o+Dewnn?TC_vY80@RoV_JMM;CPM*wIoZLJ#B$G>rFN{tacCHK zxyqk0hR-ZwsIz|_jMNK|l~R7gvo@SOqx;A9&J*kSIF41BT(ViJOX9zO?2qkh!{IS& zw(}9ErM6G@imN(6Aj9o^0A$E5&3-)ci`7LepV*!J#_$-UTWzg35AWBttG&dbKum+A`xIa!>cJl7j-QzN{UoOF|EAJk!qPl0IznG67RPeVv*wl;P(Waq6 z6Ys_`DX-#QucW*xN}8#08V3xY70rz-ypdAi$?oUuk9Od?^;26Ax;P{VCujI;og-!uWr2!rXSw4uV}lqD0j` z01A{-IVJ}{fywl3#;vZJnZhJfo+n@dGmB<8){wLQ7YC$~O#-+tXrE#r2l&mv*6Az6 z>IL}C?o_#h^-%8T)`@h@I-z8SjakK9)!xb5w~NF4j+jRbRyblqPXx-pqsDJhaSyVn zUm6RFmyfh!&78%{cWHR~=F+SO;zbW#*nfUN~SIqx#%|GiwfyWvaci})=>h3pbPt=VUxWS}BU zx<_gztHrqhNkPjM#mb=;O~6|FeE~I<{(0?>a&vZifh9mX;IOYQPtmg=%oc$ol=mZw zqsAU(b2dgav+`on6UppdyN5w-GG>eM5z4m_o~1UEPALU9fk$f9V;T1`yL+ZJ%awcH zm&!ZqcB$bhPKa+G_IJ5ov~LehIlJ)6uzWIZ39#t0+kB=Y!R|Upe-E(PT0mOnQ9JJZ`1w|M#Gn>>fx zZMg8c{5R(3+f0y(619dXAEVmVJb>?-?|mdUGg<9z3>UBQcWYdH4%Gi5=H7n83QFoy zrUxU?&w~7_g0429*iuvN*1cqZy8Y&G;mu9`PbHy0_TUg~3_ zT=v_nb7OLoJSZe=*v@+f)G3GZ+&Lvba+v+Q`#(WwJ8fv3%4e!heHWEJ%(Vp^eMrpY zQ9jd5n004UKBGv;_Ru+_@6-9Z!Bsmyzc!xt%R_C`Q&QFRENK{5E5l?RH}rSp8l~Y-VNYW2?5pNEAR^6FVTTi3%py#485Zgi)IR0sIB! z*4MZ%8Hb_#ZNHk|BMjh{n2+}x?o;FW_$B#@KFqpT@cL`OHxc)Em}N<*S1P%GX2How z3up1o+)miA@$`si)wL@wfsSr}CT6zrB5uv0MQM+{ufs-1wnwF2$NH;v4P_3VtC77Zj9}-} zJ1RE_2yFAIqS8q2W1Pgr#*R=AB7=;s??zo$6min;;^Up~b0hkUt|jYf#aw#X_lQ;A z7|YKA0I?c29A?Np4V&pGduC+qpBtZo7YhNDE|rso2hH2cdKl5n{XJ1fT9J}#lh#<@Y*@(DQGB?rz1yoAo`0XIacWycg|k1EbSOG!WP{DEb$a*t>XC-(>XrZEPY=ILjkCkRwGXj!3)9 z6oaQ3Kv#Tpp;dDmhUuEu!(4Su&GXyd!hqSm?-V^&idr9Oho;Cq%|&eG6etV?OwFjk z4FikR6B!6iG;P#wjk5Rk(50VlISczwx7==ym|;| zvBD^0yR)Npmw)^bd^SdI)Bd-a^bMB*V{4xHa%GGY>&AvkOc6=jpd10hS-I?dx$L*Q z_g|fiQ91M9!WBQb&f-t?bA2EB#PZti@<321QEgV0K5+1-&eo$;WYl%@1{Sf@1Nc)E z@l6(hU4os$m6{|1*d^|ea?>8&q3_kVE>au8A=Y(A%HNsZ>AP`X>*TSQc8xE=7pYhx zXbzs|1Blge>49HahV3rtY!Evnw4whE(fib=w7SEJ*dd*1cT=9jioxJ1r50sDh4Gh1 zHt?p~1jZbIHlom8R!#g7-6?T+e_Ty#2cq@AZHxgg#B6^2h`P0xPnd!lvgmbRq=`|b zphlR&fmzEx#5|((kUNv_D1Ou)_&PkXzCJ}ifg-4YHCtP0zjMfUzIP^7;cQosj&EY% zY{Sh$+~+2XeVs-u)(ZSQ<^mEP6!x7-7hIPBYq_K$aJT`pgXbAU+IMtP7h=`~@TG_} zWJ@%3WsRejcK=Zbkvm{0zVP+zGh=;0<*0R$=5UI@2SLMWq6d)@U?U@2WFR9eT9t)w!9!h^m;AxUIv6(|1cqWc8K;uR>GeWA zo5pJ>LA545brYS@-*6S9KT35$OkMv`?iui2zcsgpFUA+4`qh!>I%8Vt2rBms;PjU} zjz67Q1Zt8-a?j8d#fr2N#Ugi#q}0Wvgnw#18Sk)D+s=g(=HGi2-Ey|%AI$drid&ai zw@|u@n}Nar$l2jAJ#W`+NSR?hWcBd5**{40!^Q9Hr343xx$QcqmMC$LUwaQs0P{rO zZx{8^^!}lgX8o_nv$w$nypKY93Wk24hA0Nzpw2A$?AnkPPADNnPaVNyc?jDaiR;QA ztsP;PrT<@o9^vI0!EHa^V!?vAN8XII3GvrPa##%X33c@?sIeV{Ya^{f(!rl6)Jhe! zBjuSCmqG^t#if|nLEc#vj=6mg`!kD3wlYmu-*qoh8=cDO$Bf)yezV`G#Zh-BS?+SC zL<3#SpaFL*tFEeIZiPTYzdN{)gNpCO>N!hi1)kp@FxY~=>U!e^r_=NU&65*)yNgVM zoxT{7Cc0#YKZ{qk9lh1^9pfpKNly@_FcO5iU9Rh}sh_W~VnHk(?B3}FPJOFm@kh}% zlG&qpfmnhD*vl&u1pzZ$3+absgr>O$j0!QgT>Hv*Qq92bhdl0l=hT>^A4gRY)Q zD|6STJd@j|Jm3u~5Cw}MbYwj3RyWR)97Y4R0+s`y4)i8w2+=)JmBH3G|E#U}8iSA+ zr%M=I)u@;uf-vD(wd=LjYI>|6WDEbIo}WyQ3ev+L2JgZj-h>Ufo@D=IDWNnm z+%W@gw|(y*A>nQQqK7O!-U(7;hCOF~@J|~z0JkEAiUTD4r&OSN;Y8|&O-7~8N@X{a zJRU%K@3#O!z~d@>$!NF0i<6&cbSZJ5G9B!-A)*Hgk63cEZQ*yDk1Zb)qs*=sw_eP9 z9)oZB$WV?zJ<-0myF6V@Y+))VNOHE7gV3^sCM3V@FYoH`dzSHg?)p#LEA~4N2H}r? zqzAMH!aCj7k#s|bj*uEmMz+26qY$Y` z!0GG%LUAFw4n3=N5zs(C2g(s&0l6mv#O#HT5>PnkwPAL`!*63?R6`$1|yF=+JlS+mzs33V z`tzm`t^8`qiz^A2#bAdc=`4%4;e*0Ex;4(kU;3eaAWwq&y6Ja>InKQr?E~sEx!JO65V^9S|oj(qeaE5O?-3dR!B8dGNO}{cj*Y0j!AX zIj;QD;5jg5UNsU8(oc*0PZFv5f<6T&sT z(%IUcq1t=UCk0|P?-WFF=4ONqDP7W4RFW^&JOK0Gp^Obw#*qwq<_m4T zU$`E1oXqSgi1`d+e|A;GPC9k~pnVgDfjzT_cC5RwWsn+^3 zL40!=7X+?(%2U?I)_(6q!>0CozC~xhwM%fCkm+opro06|*+QMGGcAr-$Cy;f5+$0R zpsBvtKS2ot2mld%G^X_s(6dWCdKo~qwLqRmUTkBc%d?86y$q!`?)^bM+d(7VR;IL&c2W=6gr@$aP-Ce0S~jtLLsJr zgqyPSj1nKJw&hb^)h-WbMWSqz87=YR^$Z3;@f-R^5^qTLDs{Ye7o15W&d% zCoT!D3?4=IMF#PwiUB|NvlGk!ThGuR(PMDcde-n2ik*G2tx#-C9qh5_3IS%wm2NO9 z-$yL`qU_ZoWW25S!*Au%K~Bqp}SF<{_q9Az;V8D+uyH#32u)3GzT>V<8X3$AIC1MEvqV0=Xu~T{lnO zP}%|l{$sP1fx(k}Y5yK5dO$lsshMVfp>fJ zul!DF?sVmr$xmq`RnYEb8SGxF6obJN>|QLXxr=JHiAW;%w5vv|MUH(o6*T{H`jn%K!ca=#g|7|I!>som-&qzqeM(CN za$+@xcBCT+8>r)Rt(&c#O|)D>Yn<-QCbkJYDhxgOt)}RtaX4Ktg09;&rQkP6d**W5 zF%_vsiEoHjrwIL+w%N?8*T-%awWoo{3{)qcXLfWJsMPyQy9?FmC!$V{SBX|9tBEze zx^WeBG|7D+2XwSA)Y0XjqZ6?7YQ^~N0H;OBMLt!EzQu5;fnSZC>PZQO$E@voeCx(H zekiYXo0#fy;bzR{pI&$NE%=c|cC4M~TtGnRHBJP@gC9Y zb3#Ab!M85!<1mZf)4*#6Kw3>dzxAs9O?uDgFUfj%odK~ccpWPK0Y*K)2!+9^e*|vV zCP=D*1(IrzqDwU>#V#D(MQ#Vsq^IWqi6a0edD45}qS2`p$`1h|exA|~)eU*JLtu-C z!ZHs5*y7;Bg`-krkmL1XKyO1CWMJnaRYK4DFYIE`p{t>mX{9;m5MUt zI_}vF7!0&@U4`jnLON(~b`H8i@)O{uRwSB>_+apY1X-gC#`QhW#q5sgtQd*zbBBEJw#aY6*C5%6t8C#{A%FO)^9BJm$+NODYLcKB z9CQUe)BU$rn1%5X475}xK`W#VNEqouhk00jJ_3~KW{Q^BmGcv{=Gx?Tzl3(LH+QUO zB+X+5R&IQ~G0{N90+0e+9RVoCksy^p+h++5gaUJ@_5_ha$Ik!4+JwSou+bRW)D7$iAg4}^^6${r0ZokzK zS+>vpcf~m?EtM}&U)*N)#VKZA=&bCEDf*+A-FCq;X>mY?k3Cxwv=StSMBd(?6GY zyxt=Y4m{X0l9}L`)kD+hNnmu93O|@49tx8n8Q1{L7LT#XJ5?Sa8K^~12J-YKAaWCx z$Zc{v855+Rl{rE9S56Sr9SMpo5+I=fZ@r%sQdkBFA;XXh2bF6*05pctFKXhvH&O4Z`Nz%5slgb9k%vu2=4-RbKaJ& zlvAZhlf4NIP<_S#b>LtQ&>gD=Xc;+)9fB}k25|)TtM}Ofgb}>Zbw>%98E3sbdh*-r z8{OgpNaafN-S8ivl)*v+@G2z&MKywhVX>5%7OR?drNv60E9b`mV5>5O<-~CDVIV9g zW;sjc%$JKj3gb+>%i3rmgH=+i?#S&id^Znz*y@(@(f zFXss}ZTggju7vWACIT&KdI9r=rWQL$3o=v-7p3t>IHrXi;EUh_#j8gEGHzc`^N6;X zU|HP_wQOe*@1F8K@|Ydh9AXQZ@T#l>JF>olbN~Zhm0GHw^2iny_Q`yQ^YU}aq=Nm4 zila{M=bf>W$sqFW_IwGq(f?Wd_c}K%h}bx>AAnB!4naxyoc1m6+_XBN7dxRBIk(J+ z);R4MPB%wb@jM<$lf;s1`$cOw#Emzo^UQ={k73xLwoL{I~DFc-Dzw zJ8pS7UF9l=M9Ap0`wimPo31u?`zOcSX$~hmg3OLmM-O<U52b*auMGFGV3rvW_1E&mM?_NA_HXB^kEsezwX11p2KjNiW#3ySDycolz)D| znR+X^87l`!@vQ=;=Gih8I+FHq*&wk6=K$=A>=s9c&X`Ti54_e6^eJ}&RFp+USdbyz z5}K3O*Y48Oxs#)t>)=g(=zv3-u#tV z@i`yA^{#`bquR&KOpBlSjpu#QKd%&)btKusSFHGc@KUSe!q@LaJ#z;M2N%;ZGOY4k zf!W4#&phwJRuY&ZVG1lgS!&!_UnLy+%uT_tXJS+KP)uJ_$u5VXWDsf0rC^o-C<}*+ zg8W~>X_^fMON$HW80{_(-p?{`24}nQOH(z+JOPEi=RUw0paGUcnv!+4irezWHnDK> zrF1t5Qbx#Oly{8DrZvrt(Max34qM1xeOG3l&+ousURbqxvD6(wGO;E0gd^AQ((*+q%&lG(udlUvVsbh z)Ls}skSx)f!(gH?Nb`>>hZ81s!c&5|t&fH)KRFndS{?tiDwk)!5K>CFIBI58@1e3z zc#-5)B{8Sak?TdBl`}2T+PXJ1vxq?gBK&`T)M3jHP`jmyYbuH;at(~TBq z%xrsffNnl4pB%(02Hv-gt+BlvP=1G{PPkeMG$@LHx3r&eA z_m;NWw}&mg&gT+L$@J|VFzL=$y&P58y1y_GXhk}_KT^+@ZWUfqcCu>6tOj3PVS!dJ zU-Yi%!o$6MnKRM~k%fmx6`K}CyOx65ye9px<>u04=A51+HzjRFUFDxH+SwVGbG(&0 za1&s$Pc||_N{&dg_l(~TCX@Ur7MdTVXbo?JI327_>S?07>+aJBnfQ9z)QF{+GB31bBbK< z?<*EfSDgSa{nY&{mrqvrJaHT0_tlUG@Z|3Zi8p^c5+^`EoIQxtg7vi9n*mX51Q5l( zWUfm{^(nqh@dOnhbS=Y&hfKXwAX74nX37!+4M8YWB5|X27qqZcW6)~I!~WHMgM{BdB4Q6fcl|6i*+4z zQ6zh}!Q$xlxJ^H4|IH!Ve-ZIwz?gm9WAOFnSZ+sOJ5f5(|MuCxi2jcZtRng!MZdVS zgT;Z4H8!`LJopR}?V6nfSTyE**XV+hzs_SQ8h#cajb~2-c83>qB){WV%%Kg_-%y zUzPbKxp2yBECm>n)=f1(fRLE*qKIM}B0yqVy&0lTRhIAe?(rDCpNKmcS*`V~)N1r) za*!1|w!}x(s|GRxQ_y^$h32~>bH2YS+O(XLi%_sM_a;Q!-~<4pKREduS^yysgNx7; zwR;AMy~QCP?~`2@#k-!mUh3S6O>vPDTpY9i!9byjg{3@#P-tr}47S)vb1+b7iFX}R zzXt@zp6WQ6D)C~$`m=_n$iy-8yb->z)OB#p;@tw``|~)uBs=eqRUh3~{ipBqpd!8D zR}4xo2JafcoR+kVIxefwpo^a}^FII0|19EN%&Sv1P? zY*^1E#qWaT;TwMjkp_ob1F+`{lxG4ADA@>0$~EaT2S->Cix03=snqm;+5<(X!oE2}ByH<73tGPxmhLy8leE>)N!przk+cb&b?4dW zcBabsyXeltVq3sb1whET(GhZ?Zghm)EeIi3+2DE zX@_Q8-DgL>ZVI-5hf1X8BazcW)ypjqT<#eiE|=zy$hl>(+w{3@=dCPZi@F6=?ER0)`yPCh0BTKF zfLc?^t>E55t7x06lF5C4eiCg^vtm*wou!j-RHgS)MD*lE#CzJ*{8By|M)xg?=_z_% z80O`dHZckmBeJNsCOE#*GvLxaIm63OK5Y_sSyET5<~<+=9}Bl{i73{W#|&M%o`e)a zj%G&Bp^7i$Vul<$kn{Ydw2pb6I-t%JX#QUJe!+u`=XnpLy_Lqk&)ik;rj<-daz4Do z6H+|bYBaib|AB8DvtN2V?bC&mM<UFBiZF+;C z5a)DaPzjacJD#c>Dkh?B9ABE@hd!*#&+OEHf)?%Sn|Zh2_!?0Vi~6n=JujPg3aiL* z=^0WH@Ye42+`z9UepYt7n)sNyAv4DVLgFh_(;<+D%gLpMMYLVAtIJ}(KLEy|Pk!z2 zt<-Noq4z@s)`!J)?3SCJ%OAjEz0D%wS7y>}M z^8jeqqkhirPk3ZYtr5aId7?A&L8mCSapE92+jJ2+YYd%zP-{%HO0;LVj#@n~{6=#H zJ>%R6@2_FrPSt?o-@_Alm_i=_Ib)469Y+U`Bm(dWq;n1Y$<63xySE*!Ng|#@9=Ht{ zd!0B0?rVkX38m!g(}YaZcKyU3S>yMa`Ahx^`Jm>Hiux|Y?U|l*BSZ8uGXCxi9&Ibd4b@(HN zM~&7k=bWgL0l+#L0Icg~0_!yIHjf+=i$m9it7UtLV1fRmJVyPR!xOc62C&X>6|hd1 zVxYXS4gl-E_>5{nA?-OB2v~=QfOWr6NCfWYp~vtblq=fqPW z>|7WGtgB@L>-0U6W^Fdmpp!As$pQ#iXTSv3<^KZKxonP@FB-ZK+;;h;T5{-}Xpja9 zjqLCqNRJo+$AMfOkxmy=y4qCF!f4=4*m~|3s@EWZuQ}0vmdFEfW9Qo0mY?u7PlmX0 zSPg)$d8g)&%l;HMhBit1{R}*5%&A}_{OPE#!G+Zz%xuaUZVJ50aMR^>uh>0?z^yR^ zZVjDkSEmlDF>A7q$#Y|*j?zzR>)}uL%bmraPLlZJso&PCBs*VZp9?^3jxQ4B&Vm|k z{fD_{9I_CjmOtdaclE3p7`cqBCn&cTRoqb08`L(vqz^!{O%UJ?)X~L4b#y!aQAel$ zyE?i{|E!~HhwA7Y{--*+GIYZ4VnQn0Y752PG#d|^V?ZS6fa5b&WZSB2(0?iV1~DFl zcIvp>#-v+(#pyO<3p>r#8*oTnZ!dtkJD!diiFDS6rN{Axk;oq@?J=a5uI%9*7el#n|79s%(0u^%gHFCi!(_(-oUNzPvQpRO!)+S*G^T*;;=hp z!~KOP{NF@*J1u}M8DkgmYTD)1A^|8f*&CpX3(y^{a9Y%0261sLjk-K;&_x;{(hL`u zd&EA78beUMlYure3cy=afV{Oh5Sa27$Z2|{M!n_aT;-eAP`GLCtfMeV$F#4in(3|O z?sj_w5)@3F-iSSC=7FWslcZv|K6T3Aa(YjI6(Oc1RujnrR4XGDJ3!gM-u^6aWSO^E$vfQ57wXj_A|o}L!`*rFm30{f$mu9vbXsiw6B(K@Io zhKd=D*s&=+toLs837+ctfrk?JqIbYf`t4GU@%-v=jHf#70Z3|tq2Ru_D>***fgM6K zQ}GtdiBa_pf9?WYvoE7O{s>={i<9BClhzxqX!+;_b5-33fNP+rYkQ2k=)Yt$uO#F? zP#0a8m{J#QS#)e`Ck*sEUNNPB&*>oWp?Tj?xeuVaahknn7-zaP>P7TpP(#QwW2t)n zEl|O|&HbTg8t&?|hh*^qzd%Q}T>yMC>}uQxWVdkg@BHoXS6$*#mrhW5sDJXjW^SzK zSMUd8ta~(I-KysV!er(G#+*mu13dd?VSWijhr-S-7*YZ$U){EWM;E!zI`BH?%x?_<*p;*Ih0S+=NVek8j$3=%k z?_l^fHy>Q$nM-mgosI0BS!hZ&dJ~HnYbpN$SEaRj*a9i1hd}Jm1VXt1WS!+9YWf%R zomC>)y+tL%u6fPB7kKk|^`S^E=>kZpgV~6vhoAaz>!nJ?$H3dKm8BYgFC>@4;+9Lh zf5FB&N*|xSb?JD}6u*N3Qz}K!!QlDip5&6$O?nYdzXb<|3v$Y?JzOPBw>tB|C+MpH2;Asg@md{IQDP#;l1r=}@8$A2lw zB|td9tNl{Nj6*;NwdP>?Chd)sm8lkVe(6))+H(>PLNSc;( z`8)%eD}h(B_FQc@?5e`c_b>Oqp8_x2Wzc{*afFm6%n4J%IX8eg`QI_Pe+sk#D}PQ*G1E`nN1SsH za<7{qw4~)Pn$YO1Vo$KUX;&964-{O~X5{V;Di70P7ashpIws~+YFE{6y&;`MfJbW3 z3S>OYB09lew!{p!31Cotz3T=8e~z@5KDLyZ^7u|S#l(-P7`9f z(5INA+=C{)ix}np%r1mAbX6>AaoW^bmJ{liJi>o@)O; zARd6fKCVqBxi(F+?PWBZMQy9TMyV zhU{emBwJ@lV+l*|1tbt5fdOv2LLr=;B!shTgK%~Vbevs06K5Cw3uhOs)(bcT!qsDb zl=_O;J#6;C%NWx^E<^*qRjEzy?Cc1o0hud?hro~fG50|}B~sQ^^R>YdS4}`-&a8I% zXIArv+!g$x0l6QprRj|q0ZgbGcM*aKZG~V$>j6y2ZW|-#9lF2+rOyE=3IiTvz|47r zDEtbb)(~Z+N(n$yxFBeXQZRS|z8)powoqSClcC9|$tYmfWH_(FETQs!#UX)^1fc;l z>r)=lDLbIURvY&49*}GnqJwlKtCSE~QC6gd)=zUSG4t(7oSaDh->q2bK=d@?ES+5I ztrlGa>$<^CffxS+XpOveR=Flc4Fau&LZGz(2(;Er2d(uoL2CxTKx=Rcnzq!{knLR7 z?eLyPAiV4fLod#RkYaG%DweHH0o^EUZ8xfIQ0sm3zS-qi#W9CXlLQ;pNkX9KZ0i?| zi?F`r;)%4tI#a4|?PaR3aFR;;8Myijaf)H4a$1=sl}et#QyTmRLnljUO>e$t&wZg2k6#ecu3@uN=sJm59NgXUHFeKPc)=iQ ziTo=4;=vhn;?_vU^Kf#Y|~U)pk*5#I=bqCKOZDU z?$THngr8nc$EnWKvd0z8wIMRe&2qx&x-45c?mt-h(2qr(d&AqVP%!X>+waFxf9FST z=lhllic#%PZvnnXryp#4|Ljt5iE5W}zcIDcU-m%s@X@1LC#e1lZ6CR}OVc0crJ`YL z9mTp%PfDayy>`|?p63UaCV7< zd3z=w8z^@Oj=TPLS<_i3L7%I7+n}p9B2%`li(vb>>ahctEFTi#z&5&D&NRQXA+$F6 z(3LA!W(Alxn|^<%Kc|c1?tff%RIo57mF~DWU;#Pn4i@mKzaBpx+Is8u^xj*$#DR;= zoXg#oi`pzKoItt5{NKBO3U5zH7>rqQgi9&pUhWrv1R^jq|v>Q_Xboh)s9|nStGpiQFNuH zAludL`^~@*TU_H(>;0DV;8ttPp%w;@9|BWXEPJ8?LsoUj$243rjOF0$76|JpB_t;O z*6}9e`!Ro-y&EO%jl6K+vZYnayP0y;E3;cbXXR#t28JH$AzCfxKV~ui2jf3o`B7<0 zK(3t?fUbFYMo4Je+bjRP=&md9lxC{-EdTcOKQrf4wtp`L{N( z#U+cgMCsi$525dm53*s|feKOlnucS=s)1Syt-X=>PSylK*yDqjfB+r&2_0N8mcts5E`-e*U7VeYxl#W4A@G z@cpF^+EC90I({6LhI&r&ubwN7o;WD_)BOCJ5*<}&ZF)AiK1ar8!T&;#_Q>;KVZ zply5o*80=!&AV;6aZuZqt!P_|N~7OiR=Y+2f4$qd|MhN7h#Wpt7uh}CiwBx$i*vjm zEKL+KGY-y(l6Ign^}|KKkQL{O3s@iq`7W?ujzLo%;d;m4P{wRKENH$(r9rH3KXqOA zzxd6Ypz_?Ok#b{ZmN3#kCVlfHHGft@?gGMp_}goezF%D9)QrO>vX?Inx=3EuhK;RF z5>Im9)wMdB!%n_(l1e8;Vqn!Fl)wZ;IQ5KDbqkHS? z`3)j)WL0jM4p2743x)RQWMXt;v5nuh;B3-L^&JxWbBh1EjSCVPud>e=nG6da&rm%1 z$^|TPhCAWnMH;G|(Pg8T9+S}JFsfGPI^S4x{RY_gIqdy@iCPc;A4Oxk>{{~ncZ@Gj z36aWJ$?cN9q>|4?u&H*|>5E?SC+FDE+M%u46Rmp9D6`? zIthr%=K5v$GL^mUE{AvPQR zH@mD=wmgpA_JQ(&VYGk-+5bn}n}8*iwtv7g)0ERRqtmoFmCIDql)1HPrb6YErKzP& z?pm6exuu4rh)k=MrI~A~khx`Uxi1K0rMRS2E{KYhil`vu0w@T4&%v7Nt?&Pz_x-=$ z^>ul12o8sHc%J88e)sSG9j%q0uI5B7xUb#T*HN#*nld~cQ?>S&6)R}_uw0W}bFqMq zbFg4(pzYh|{<`e?pQ?$BQvlb>+;I`w(&uBdjq;# zk8>ts6LM2vMD_((mlE%E80zRP$*_}an+?@mS1(fUZ~lhXcm&#xnEAD|G(d7sf(7{F9 z&}}c404=9qRyIAdD@UAZaHHL=b}Pz@LwaeK*d0yG&&}2-`*E-xy*Sci`)4!$1m&cR z?(MxjI2sWIseF{()1ynMvO6u(Hw>4~ zo70)o)oa3Ypl<_b{NdYPHY9HY12JySoch;Qc7mr^MX!k8CIeUEpc^a}voF)7_b56E zL;fp6FMu}qi|#8Dn#&cH>~$P%Y_$^OCv@^X5}HRpjIvu*UKY_BtZvueKs2051P;s~ zmD9r|p~`MZq#R+iW(2hHB*DdH{88|{3rM2TbaU=0iG7Q3#>__yb#a=kHr!|G4p&Hm zF}mK)jmR-DB5RW5BeMA5$0O1!ACcNGj>v6qr-Phns|e1tQpX}g>292}mc{FBQ$P$_ z^@_q)tt4O7UyF~GXBF6O(quY2G;1Ywc(8%p@ttRYaD8^c-U6Ko2A;Iv0qtdm-U{5n zPFe|5_7@*yC?za-feN(28Ou1d&RliDtUH`D<4MW50OM5Eg$v@IVlkWuse-uZC7C{n z@uXm;D-scFFKG}9zB|4V`nF4(KKiz8f$J@b8m+#wG5GvDNfz8ztSqhpD?3DZ#8QVA z$G4Vqi{sp;rx$3QU$0qo5-g7SCGy2_;giLY^o7MiKuM8>iAB)42QVMWF9Do+xr+oG zU3{DZNBzER>NrJPP?8NUac+6sgtZyV^aZoL0NUawrCI;>HB?w|>#?%Z|K2qiqohi9 zy6)g)r2|dSIZJ7i6s#{n1fC1PZ!b8wari0Lk>hD)z?mV34`UvwuR>>my~g2_JarPg<;)v1zUl%qeB;4ca+={pWR>aj~@)hyN7gof#Us@3r2MPi< z7Y)Ewiw7WMJ1sZ1=ieDywdaqHl_UOYxBwa3+Bsu;>|rL$b<1 zXoCT(+taZyylXNVtP7lR?DwKatmR^wjUq}~q%KnDkoVz6urewOtcnN>%3gm@Qa}6p zPg&3!Jouf>M-FN&^3~Gh*-M+^Klgj+p23yMOHk6b)hMY6{|OfJ!c*CN$&R_8`1|GkJ8D+;Q}xnW;K9Fh2L58toCi<)#DhD@{YCYc{Dsd= z@l!R~r3N)}!dlH*QG&|bjM0;P2n%j&fgLI~?5t|=?X z>nn(RHDp%iT()$6&pu0f;@Q5Ga@~;(zu7ic)QEFAUtdFE85m;Qxg~P1 zM^}Nv^$Wghv$^JWS{u{+ZOjj|d-gYK?oIOtd8OrgydwcwxU7hpOy~oi6xwk3CkqRJ zC#9|ec3U6CTsn2UaGl(fhQ9Ztv4lQMNk z2sF5ckFI0$U0sWpPH+(WyC3`QsoUY2=WZ{Z=#T8;pkv!>ZG0NsVZGF66$sIuxE)@I zPIkENz}RQzqVYX?tvp1dvk9pDtI$Y9X-3Qqh&~DdrYoTjOjiO;GaF1-ZTWNsgEVLV zLPP=DbSVT-^9Gwu!yb<_#~YdM!$rYuVV3D-9-J9%Qd<*Zd1_{C$5w96BGT3t#7d^M z=ctz{$wqS(&D}gaJA>`?WN5$5ew))cfJ@V}?f8dLqAjG!UWD6AR?NPYUS-)D63H4U zC>}o$)bS9xQMmGOP^A*gw!1fH}2r}%c6IKkKrmb@s(XrQF( z%(I`tQ}n=A31#TXIS63p^irOfKMbq)ocqfR*TXK9q9p!9r?{Vk%-G%z{(w@F;Q^5t zpQt29G0f|~gqkw5`I-v`@avpILK6oaLP8ntr$a&`+EWM>V>UvuRdQOt zU>iI|eTPw;V9Nd|+R^v(Si3?p7y|3dVE^&WG#mf6P`1X&+?S}KgO8qNI6m>9Qpy8` z{l&?3`*gjXf>)dxUYJ$K97(={h3>iX;?R}4;{1yy%bNkl5a}ULfa{7sTGDn}U%(hp z_<*#XHy_Hyrwy@dKh*Ejz?TJ;VhG8rT{p z*Q8M-F)W?5Xa@;&l%GWpI+O%kZCi^YysF`?NMYYLO3zwKPeCB`k#$ocA%h_?5C-uc zlmK^j*8KoXK%o#z3;jEoMGQv?2~G%mMs{|Exe;hE#>;M~n8QFaMK@YsHIA+jwqIss z4~e1zbGGtJ(-}GOH#tS?NdB+*n~w)&Xk=)VQB>NZxHfsB2gc|-j0mo%czAOE+MA`_ zZE@1@7?5kfn*NPknod4))V-Q2aWZ77i_$8Skc7trLQ{aEojCTPPf!5xXsvo?_-PhlOb!Ry22W6Uo z1gK1t4wY%f&&bO(K1%P)G^z0)m1(lXQf!6KY)`OJ$hq6+xGx8Z^D^A#iFZl@cVc^y zNk@ECr`dJJM>gs`D$IpPX~8EX)e4q%q{*@1pZs;XUmq#b8?4Y2{`wHHYQDixO_m@H zJ7oB5BhiBA#nO}1j!Pm@4S$B=N(k!Ld4;_ug>K?a7}Ahhc$r_@uco=w4tQ?%$W$G` zP=*Z8X-fSku%x!57z%r(`h)BlMecR=HqHuG*NuoMbyozRs?J#kAL@oFMyeMgM0^Ew zUDTV|f$D-9>0@1noqzoZi?;l2jke+m8lO7zE4jhB*(Na&;Ar5ncKhER0*qwe8j}+Ku2Z8}-^L`369DUQ>l{pjH!@y}@U1DhF>+UK!C)Oh$zm2nu+BO{47 zlfY}8HD&}N3@FN^giRId&nvbmPZ~3B58NTK9M|ZK%!IA}Wu37rji(zfIqAo^?w?~g zgd(mJZpBcPFC2O`IkV@8St#)p1E>2eKZB(yk-U@!h7%jrn%O}?_Pt5Iao^CmI&0?D zpx34VHQ9J-p#^qty;;20`4d-uex2%|v*jcEVqPKK@^_1z1r zl|mX!u=gi+h+ptbxh9NYte`lEJzTO@xU;97Qd1hdZ)58Ey8|oIJ9!j`qs8$mZE-#Z zWKgYyt}VY005!KDhaz?bsQ)S&zK|3C96RM9JCr1LI(ClWv``V~3 zG*Zi-h6+DoKt$cD;P7?IR2cLpj)E;VmZ{8X?o)cPa(v*1h`w;78@LK7y64EWnr#gxrs(|Wmdg)Y7Z zSzs&{J*W(CW+YZ&wMeX9{z>4#vtqK^WDwlf$)KvVos~*iNx`#8dr?1}(9hZ#%qjD~ zv0UG8GMeecOU0DE;=e9)hf!dU9hKi8YGehgJmqDvB*O*dpK=nu%08_+=4bbC0Ybl_ zkDA9^(?sz-K|fg5_h*#X&hj|-yJZr`^aSl#@MV^+yC8EV(LHsItJeRm+E7pWs+tg3 zkZnOVWoV6lML4D6_A9iWGC!$V7^bqpz`0P9u|Gu1J-{Z zLVb4V782dJo!vILuF#=xySL`xI^B>)^S<;6OZNsG<-0W`=@0(%rZxStR>Joar9W8B z>zZ}3?W|EGmLh7I&V4;=c}2BMDlX0Kt7OmNCWlbz7~*GFB>k~K`hqvTYf^_d7NajP z<|u80i)RYpCb?hf@%!S-PRv7bp45j&RgnGeg<{%WIflLJw|bfAkU?YEa7{A`HF(os zy{G43SkF$9VpBMoii7jN_TdmUy>p_w+WhVKx(L4QsF#rZcvAX^G%ctgSkzb0ElJdf zaIyj}IK)*g#9e$|Qk%_!Gsa?sf`(Nxf^;s zQG!z(pRc`oBRknv;wOydI*0DO@5BhaTTCRbJLG{5%5`=9?m{uKszXfPj6+0UR`vqcGB8{WtEFPWl<;_FEZA`7& z4{WW*O~&aS_g(x*Ue{O)mY#v)>Zmh|xpnP+wY`Vw7RR08uVL+hX-w8pVD7=~N2}9r zEekytE&%%a{!)3p7eHKz&UYZonPB|n;nS}{&5~`R{3bMHpU%Ahd zNcbW{!3t|5wzRrwMCbYdTOM8qQTKg>YK>J!;jKr9Kf@pVoL=xwcI34%XW>ss?X%<` zhhB!}6x7q!=qFu-4K4@*cl{YwB|kb?j<9Rk0wt(-<`UF{A1A2IC%ypDd17dNe-`&B zi*<;#-w9tyBGD}WM>FBV^%Kh*N;oc|Gj5ETRX#+Lybvr*%*7TVel^1! zXkEmxh`B1VmWZPwEqr1hu?s0(kjz6q9itw@g3?=}GjqCiw7i{M5phd2G6C&Edbf*B zO~o-R)f7vGc40!hkiagJ(}D}u@GdJSgJy0f>HSwp&hcuE{G*Nh@lE5YMZP)F{<>@U zZLIOJRhi+Ba9x3Z(MI}Ec~3!}ezv~ytRcxLuMgFGSXn3foBws264@S)Jb4Ce2Zg7q zuo;%5lyBm~)H1tvzNJR8?I%!lC!Vz}=38ymnQ$~qL?+G!l?BQhJFm!UuzqdF-iF~r=^+G?r);MiR^ z_v~+NND`m$GiX8>U=+?@JdaBx{wf<@I9ihPKs;Q>oa2S;C~hNNSPBBiCRPYZnHQsE zx>#fz?M7rdmKjb8hq!tzvYCF{#ZML=mM*ITVdv46lvzR*%GCTEvC7Z|JQg!tXPYd} zA-YLVRKa1)#CJ&gNK?;+6n&)n>4g+qk$7@%dHhsZCJEl{+Dg&yvz-Zfeg3U?imJK7 zP1P|c8tUzxD4XFFmL?&*y)BP{E6bbG*`KT1(k+b{!GP>z+pB4D1SlVx1rJc+N>#jH zbZ5y}VKVntX}Mo-Y$d*Tb6Huw z)VedEmDl9JRXXnNn;BcJ;fOP=4=tzJm?dj={EgqdQVgjkX2e#%vBDW$T2^)735hNPk0D$z5 zw@anM$O){msmT0`nV}<1lX$w55EzNnRXMqE{YTlDsIHxK8;S;le1}(&OVZ|r<*WJ> zC0df~Ryh>sf&*%{Ar2q})GF*wanQxfqR^H zbe$!>BSD=46Gu_5C8-PMljF(;-^g&*x1-7s+=2obd(iLdj?%U+Sb!DWs{_~B39N~| z5Xx8eW|Lp>F^HF%mYnU;`|h#$VhS$SshT->B-0dRl&i zx>MptK4T8jRU_H$Y_`aojNxVx;JycG!DO7W`b<`X*Sr+HGc&JCzkU&&q6gU$$-KlP zixS+OTb(mf3L|Qk|0*N|EnhTeOP+kNC428Vh=DC(e`HIHJF~@4(TjEiTS5$AxIwnW zHgpCxE}cAcCL6;GcrFY>;V5FlIb7I|TQ5lZdLZp2RC!9V{{DebvKsZ1;`Irh_Kg|v z0+g)w^w@)JR3J#03iBY5rpuDwep80=H-`@64W+n!_itk<6%~2%By~oR0QURamN?FY z^r}{y&{~RSQ?)%*#tn0(4uxP}jhblJi6nN-r+F6vw4FDmd`Eh5srCMxt##Eh697tU z;&=Dr$i3)Aa@t(Tu=VeQs=jOemF0SsW+b=~1HBk=vJFURe)$rHl? zKwes0f(Z~_Z<>zkdQlti&AWUP&)V*RO~N1XZe0=t-w@KUq-g-2bXG!$mYa?ey=Z^` z)&zWKgNfXTKraG(sXgQpR@Q?s3mo2-%S}#mt*u2XlvLrw(NX_%`QDr)Z}AST@S4sM{hH40em}6(sR-s6v6D|8Am1!tt=6x; zGV0N&ke;?aX?fMlWdJ|f=?>gmocs1x=esF|7itnzg#^EZ@8+gt;D;%hiThXghO-W> zMQg&rgj5S)jGBT8xus&(m>a-UqpIMdQBLNeFm6E0%uFS@EQ2+m)>s3*I2jI;`=dM7 za&)(A{0r!=i-}<1rzAsvvAFqfboa$i=lA|AM~#{NqxS-?YKl9J;24z3>AQUAXfW?? zo_R3O?2m#2!MulH(g9(fKGvlPjx`|ygM6HQ<-1&iTv2ADCDNxf=tkur`jEIFo-ZP?@rko}0{|bXnl=9V)-|l1A zsh*dHzKPlel}sn!6&q`derWb^jEK-m1jWXLW_hu(`IBO!(-(@30$)lW!9lODkic=f z%cTIO*Fibc3t*>IqM=E4NEkAzK-ZI2w~ekeh93yJOGcUw1Cx%7>mDhAKB6k1rx~;i z;4cQ51KeVlHh-Lc-b`{9ki`zRp&t+pe}xXQ-%o>#jK~CH7KTPSI9N1K(G~=N*EHqF zUCY8>^asa{U_i(H4ssPHF>+V&B10ZBh9QSRoGGVr5n*i-X$5ag%20QOMg2e!%#@>} zG74(8y2ph@{YJ8BM*NNtF_&f!25qeCJWq0QV%=tp5A95<7Of2)X%Mn^V*430!G>2W zl&OoCd7Fge168fVJ+s(xqnzk-*`d%nqTE@=$P$(YB}-pVOY0E9bwYz4aoV)B2@zf= zI4%uuL0p(oeOs_Lk1gA$Sg4^FYCZ;BEiM@#4h~@uF(@ zT)c>wol!P+W`THd($~4BEWm?|mjZgs7M@@<8!&<%d9##VHCq8S9}wTZvx&u$0*Ndvh_GxeF+yvM>X5q&Wh#(n67O&cK50&-x4FbCf9NC zXwy~xE%DL4q6zvkJd;;Mxs6URfT@eMfQ=E@56y;gO0-61x>)hT$s)=Y9xGkKoDFM3 zCs0{Kdd+O6h*BXtJ|Vm6but-GA$hC|a=PL;bVoCJ5|pwXEj4jsECS3X9e;<$NzlbyC6+yr!!QPS~RANE%<^GmiP>Mqzr#nh9vc^}H0Oqp%-`WoU))k<}z|ypt(*h1y#62YkAv1tJ$djjr zq&?a5qe03T224Q(s~rTASVt&e>si^;k#wQ*gj$ z7)Q5T;lPLDL1gLHJU$kZ9sWpOdI>}K8q1LX2M&s)XOPR8vAV{Yfd~Wt4U!z5g%O6X zfEZcowty`I5wkD?A9e>|pA-S2T#2XkZgoMg8yp1@x8&5OuHmhKB9Rnv6^0+0yIs$bh|I693xS76h<2 zom^~uIB}bD14W)7)g&f?`52~CIZbLrNi7{E#)aNt_pn1jZ|b7G1UG_w>P^Veg-*(@ zv+sg}q3T%>uu20`*`i5ZR5h0rJj?1Ko@2W;M{N+F!N7FZ9}5BIjZe6{<` z^*6QV4=*P)8}Z?Z4Acxe0cwc?_QJp%Xh zuoLj*-(9fz;m5;Al=X+kd*|N_V*KH%eM2k-PHT~!t!C- z`86z_;TEF}Q>#!W7(pVQ4zJX|!MqyC5}X?z!P8ll`hUCz|8tvO#!v0BNqgY$!pGCC zs*xij(5q*_tC81^w(D1jQhT=Ed*JWKkCb3@3YP@Q4!)2C9$T?n*mH5>yXy7BF6;9- zfB9VC>ei9mJAXetTG-z9U8T11>x6r#3*3d(g?Od6`$~;-^PjY=JuD1aeOP!;=~}e{ zm@&1Rua8dD8~q$?)rEF)E;0H`JMMgCx%X-BQLmN0-+Zh6LOEEMHNKYXVjPuPi6X(C zU9KqK-75(Z{fxv}yY?qgIua|zLHxRKN;`5TQZ_NWQ~4a}QgGxT%<5@3!(r<|msi4r zR+G0Cy|3JBM*OV2p{%@j;Oz6}wwjas%bX$tY7crh8(Wjp=aFni3tUO(vZ8&H18M`k z869`w^k%&fpF{2tX6wqo*WcZzAPCQjBEF70`TZuAmFu209@pZ0*_Zd*gV^nlrVGFB zsDFFxH*!(KV#P-EDfXr3t0n_Co^D@J`C~x;%jLTseLHo@^XRaZS=FtYKglJ^*T(oe zDYCPIHR%^zyxo4yDVz**@YLPE0f4pjks=4>p#A9MuIw`_mrRRh%h&&YMt2C$VI{*L zcs7mJC)(MT87$bUV!-K=Sq}6cwq|GAn1)of3t*Emn0Ilc8#&%ni=$Qi|cpQ++~ZWX)Kf5y)TiRRObiuEc5E(SZId^Y=gE<;S@hPOt>f|@v@~-d6#uhM?Uvpx6}>m!$WqIIN9{?- zzcjx7Dj8;S-IMNWYe0V;5Jpd&(#dDml%Ly3-*qedZ+iJ*OC9gbF=B||GrG6chL^mP z#`!Hn0IaPAU~LNz0&Cl7_qp9Fr><4A{QwC4pK{*_o`C!2=gPs)E?7HjE|j~@Au*lN z;P@-07&F3r2jA-ZRVhqDJOslgdx0)N?*8-`y!tTRS|iZUAT9`;P2BAO;%wJY@jHO` zW`*m;5Er!&m*DsTLz7IxE9(a+(hnaSDC%@w25<` z7JQXpkf1PGV?0qawvmjiuK>d8vYRq@ET8sPmY1L0$@p*~Kwr_$iDF`m592d>j023k;ih zO=q30QzeT>k64KhSw)hTJfnUTc_ThV-spFc_xTw*uV57vd2HSFDcN}8nlfh9 zW^-q5lIxCod><;>A+^^Iymcd?X9~uq38)qTk-0tDfTZbNC0tNe z-e0cCLyfLuwS<>o@&F!i7trp3ho z>V~-{?}hg6IZ4Q>~ z2<&^Dm4+OI5+%%r>r+YX9qPy&1cbI$!gEsucY2jfrvYk z9(5HX#$&x%@Et@<0NVL)*a_`ggia#42BD9I%kXRkwulr%^1gmEHJHKFxj8HT5MD|v z{w2JeWPB1{%3S^qFGb>a;iYi05CG^opwV&}u=5aM+Fr87=( z7-t=5w|cVXw8O#HOq>GZvfn$aSg!j8R1cs8Ao4D z#!IEAFa~hO2@G>Ra-<-}Kn-2sS4}(ZsL#EBDiPK5vS>3uu{bIy91wQN>50ejr!~GW zzX|%yMov!py1qIXw&8u){?>v6nF8O_8mG~#G(s{rOx=X~3Qt%WO@rfR{SjP# zdGvCs?|*?4j4}e8;DAK#?A@ivk-$V9D#PtqTLb^tCH zo`ctD)V+Trz6~~(*c_{22D>*Q$XjXoCyldPCc;AkQG-v{Zc^5mkc>q>j#@A0ky4(1 zsezf9t)07oD}7nS;VyDsj~DM~YvRHht4|VX!;c*^%HR#YtysaF1at}D9gERAkE z9X9A(PQ_i!0NhSj)GVFP+VtQny&3#KZbCR~I9*r(SJ*rsw5zImlx6U+o(*r3YT1-D z6Nn{BcF^u%V0V^16yF9t8)1Y}g$AgxRW+dOge%IYwMoyrfbk6^4 zi|Ps4?{O@5ZoPA`4#@H{tFXR;XO_C$mXc!s|a}kG_QLQB%HYZ%v?L&(~B#X zKQCAO$$k^mPM0KaM_T^;qjn_F!19H5I{JMAir`b@iK3B9rLfl?>TL;zXi#siP=z3b z^4@F|X0VF45h7_WdEp6mVsg9Ys@qV1>d&G%+UKbbfLwT0D{miCdofqoo@*ox0v|Sq zI!7x^vB~e+N#g+|a+ez$Sp{&%f4lP(bg%WqI7)TZ$syGpMr^a(Z?9`Am?2`^@AAbZ z2@r#spK0F%-y%_xQ<*U`KohoU?4$cuxCf8E(}!6=R@Bn8A5Is9Wm2O<|Hls!e;mWx z#`hXFCJM62VA{rFw^%(V^6pMP<9Ph86tXA8O@O-%NOY?yE5OsR80aZPpHrKNizU+| zTIrKpq2>!)uV>U{wq9{ii(>)M;Qbq}dZ2nXAby|f=j36M1}K=su0c{F0Qf&Q(p4xm zh&=h9H5=mp#Nk<0C@jEJa_ITsye64vght4SAfb^U{Sds@n3Sc$pH?u$DWi(^E`l>3B*AYL?4uy zK(Z$F45(Igq}bn4{I#Ze@9sjBt`YJ@?D|9_4PG+%eE|>gI5vsk`u;}+)n(@3ILDNf z>$(RsvqNh1hM=g=54x4FdfUwNAnP2rR6YxQ){(cZb8OxGt~8#jZ;_)5wUDx<%22nl zB1Z?`)AyT_+^U7|*!u9;3`9rtd!*L7u_`d|EbkxD5oJ<7J=coGXbx{z9VN#HwG&1% z6N1{EU&q;a8ko`<2Myv(4B|?Fx#b?re9t=s1jNR46;EC9O#;X91ix;rH!I`S6Q`(1 z#6KfbvN`oG!E&=l?SKB@0yDd;xEfy@x+8b6sqrPj9r}&eIW}&#XiNw?_|7ViTG)&( zg33|Vvc3EEmB*k_G$lKB4+4<_n!;N@&x|ZpVG{GY2OR{(^!H zT3v#Ji~VnPBu3>q$C@<<8t8P$y~h8>*W_Wh3X0@&q4MX8?%yY1JDWxe7O>OuZm(Kz zN{#v_BPAGf^HefKbo^1ih{HUYuf^+l&xMD1@ z--d~8w~3jizc^!3=0Ucao1H1@vB}QN8`22Dwe?sVzFY*%anN4vFYx?#+k&H|I{uHA z`ed1BkLufI#ouJYgfq06lKfsmCFfMp%jT7dsSAK@_6i93zoE;0zG6JJxs_2t;f zt|goxz$R+UhUZxP5P$#Oo`Apa+WKK{(9mvGY%J5I6#9siWFX0Twkba*+Ql>9S3(g< z?3+i~GiKg2gYJq@D1b=pkUbE3mhq!O>oa;aWQ&C)5E|(fBbA&6;BKaHc{_?{|MLx( zJo55Q3=@hv8@1e-(7Z)d6y9#$YAQZz1t#ubu}GaS%`2B42JPP;uU&y}3H;cyNVI@c z5>1UD3~=%p=}KZWP02!X2!0fFz(pBfZC3(!Q9J|(8yg$R4%DzKj?rZzZ~gub23q;J zUu!U(H#V5!(p`J@;BRZQl7QAzL&y}oR~X|ddjNXzl_7F2LKb=BhR<3QvUof3H$hwW zQ;%q%2LTZPPo3YIz9gZ#Tye&3)B*Tf1n{-XP9#(}mHYD{8gy&A?0AkQ<@0j~%%@|S zk;Xz!73hA$kI^ug6OuFP2IB0B#EW2H#G~0g>Gi6QIj&BwiUR1BE+s*_J-mx@S0W@W z-2Xk4V}AQv9d+5)2cVXa8PV2eFm-XSGXg)TPjoMqPgyH4W!D@!kn8$<^S}1b^99M0 z>4h

9l(gmdKRB5KdHm|13Jm@2)#!D^Jw^UgchaK01lowYbL&yx;9P9HTRRF?P2 zO!?{SP%8gYzdG4w#_^=rC$a&tiJ#6jct3MbZ|{aM{pgO_7BmQXPXZjY&>|?eerdeN zONpVMbgl98%PM_jn2Iw4I6O(0N!wYet~2{EXsbRUu-AVAXX&|4m>YxCpRV)M&>1hP z^UChO@K=A>G}mpKwZV64MiWK4_@(Rzf=Gwl4R=zl=%LW{m$6b#PHN;x%9Dl)O5VQ= zKP)C8>^UxsZ6MX@dO)?uW(64VQLTWFlGpyx$?E!blO^YN>uQZ1LWS6a;@Z)*{BN{G z72o4fip$X^@rA)(EYv|yo)>OR$UXUCeN>1L-Jo#8ojFt}K6$;6B4>|-`~0k~KhI+B zfn#j9Z&r4ZF7gHQ@Yd7t2lDch4 z?3AZmcyl&Y7-1Yq{n;@OhY1Rl%}5XlM@xR7oqtiosdd(q!{nz`{m(r^5Zrk0OAD2v z@@9Q*>}IH^0=_DRGETOF?dryYq1gh_auScGVb?mu%d;D+5*UE5;wjkqovG{K z&bYK4mbt`sK7z9(#eWtvDiEy$j#$>HmUw9_3hVC~%30f1Wj0lhLDl+Hi8)ak)rdSjG59x_KR#6Ap zaD+0+>6eUKed3ijwt$>X)dwr(ns>tb??`Ogr)C90$LI+hH|V(No_Vs_lE zqtJRWg{0qkbKp9E`T8^a=#_Lsi$`4nLVhzBo0Q}FkSnLj;sS>V(g9xQu6sFA!H~bp zD*7|#;I`gJ7Bw(5)p?`icb#BWx@CvRmH*(fmO-cZN1!{0JK9frOIWP~PaSpOewZBx z<#+BqM3&myjg$tgx~jCgR98aO&wj4z%Va^9t;&SJTwB69MkS1XQ0$gmW=YEkux&{@ zb=fI3iziAroCfC_Mp8AT) z(Wrb5{XtSsm5#*{c3VuG_Fe%GjC{@owy7<%8$Zze$SUef=iXHg_zJo@8Vo#Tu8eQ< z?R_5xN0uv-ckmIFC)uu-Ra1~Q`_@rQX0bH}j?X$6MOH~ea%{%Y3L~7i=0C}NmS8q_ zkvEZ8V_T3OkbOOFv)rAp{FYZxzrVhSgbU7UO#lV5Bvo?0mUWB$j1GNVwyP}ZG*q_M z+@XR;m@XY)ub!vaYfZ;{LNpnDx#KSWC)n|ya5x5L9_l*3wdPyb)I%5YMfpNHrf=9o z(0#o^t$r}h>dNni+Xkdd#*$h=VzmrE>U+f$DcNLW zj0l*HO*(hCotm15UkUIX;yR2f3YI!uW?Ub3398t9mvym`tEBgD5V@kw*~UI}`r4v; z<;`g3yy#;0_R7W1?!NZN-6!zRay9(&v!n_3^c(cAqzP0~j0GiiLii8f4E}k6awlxg zK3cffnZnt@UBm^ndGzfG<)iKEd;8yx30juNmYZ?9i(ol57Uh!yL@$P|&1cVjnU03> zx6RjpFJqiJ^JN@RD|9{&M}lO%)@{lE*_TEC_GKcMzHIPMU-s@HPYG9$2CHG#&$s~% zUzHha=<@DUwTzhCv{~3$T(>z;*XQe`i;b$xI>BrVDr{dgTW=5Unj{_flxw(M#;b0! zrZhdFWjr?b_KiOYIb+vr`%6tcoz0K&qf(uvu^Ex|#K z;ok#B>e$Sjv#fzOIJD~}DZWw8QE+v|yk>f6w&liue}@!aEnR{45U83q4}Y~O8C)U# z0OU;_*XLJyf-I|hPz*j{&!U_x&Qw7g^XK-54##)6jk@%Yqo34H^73-ZwVVK9-zM*m}ug$}RcOQ0N6dg1z=^(e=@mN4C za)NZCDZ}YYV$E4dMsBjF`)5I_j6}9=<2^-f-glOOt8ct^X z$1mL;E40#BxWn-!{VK+xQMIYE!>9X7CD+b#|1TImJrA{Hb!Q8?c?IM}@S>y1n=Np{ zJ=Qm=I9jK43M5pFgU&qP_fL8U0$dM# zP)_+>)%z*81FqrWzUgOC#D4hA#OHyN#f{gymP1D{#^Bx^+oD+G!^61jW}4!J6y37| zfgVLj!Xx~&dR^2}GzN@P`sYlBCS%rvj!SgNG8*NNsl%Ow0U z@(f4I@kW3T>df!~o%=lvsp{gt{N8Jx-Lja&)nk#Y!g)SfdMw$z36jFQ*m#oCBHzny znkB|O*C}qqfw-Rezmnj8`9JmTnDwpF>aI;4_Y{P$m*Xi&w{g){tYZM^4ZIK~(zWm4CJ1ul8zNVtKz1k`yPyTP+O{mY+kosQ$g?NUw3_ z9sp9ZNHPHwo>dC5o?kUQcLHZJ-@bLzEchl=4Zcg*@Y+So#lfm=TJ?rI5>cpn9amo5 zrtHkueej@@M!UXK6p)<(WjTdE%W^RZyPqwTjN;ZGhU9K>lOjzlq{#W;ECi1;#5I46 zG(UMXW!V4Nf^TN#u8y1SAmbKW6jqb&MU`Ury6Vi&A}v*ViL9yNvr-_G%WPeM!~zIP ze3Js7VDn5ZU=VBQi+sek8&L|4Z@fI~hhxmqQNvz7@~S=A=mM1#n5IjjFE&;ib~BOh zwTrwi&`IdPDu-C(8Kk=A#0-|Kz~#Yn`_SAs$^(7-md(nt-(bH(fC5H-h%x5F_0>??QwxGg zKl}s}El0w&g>#?Q5#%#cQxLKvyzFx8@CcDDK@`3#5$XE4}V+ft`8?;S*E@Y zGESKnL7_SLrUt{uJcDW71mqI;!>TfH5z5pn)X!Vj=xfG7YwPp0&+AQq=$G7W{y}Nn zkw>G64}JFO3dNu>+fZg`c1v9Ij>|d%DXtHNI-8M2)|0z!_)I|yd^%l?Tv@oyc(clK zy#47*>7*Z)a(QKQBj#dJnC+!|Bfn4AU~m>@+G2#9*E7QWlnFMnqnoo0SK)VT*K@-$ z3U-F`m8ekRgUiyA!ly2?-G6$vqTz?d9I?&Ard?)PO2XHorDI#S;kyPFd}sAQ0hG;K zdy6we;(0W6W6xp}oRG_GRi!`taC8t&f6dnGLRZ^Gn*>ey-YJle+B-+QZndhbGQhW7 z?YBQx@RQT;iEFj3>cdXXd;Q_Zbe~n!9~-tArryR%CQk`${Ngg5$GB@yZxWLhT~%9w zhB(g%Y zAkr_%xy$EA^~E2*TCvcydIv|<>wzywy{Mp|+-S~EFHyRd|MK+QpOr?x&LgaPFP@uf zw8hx;dIBTV0U8^-W|7+d{6UI+8QEM1slA!TZT(pUsWNGgT)erH=t6=guVhYvXrV)e~rQ&+RSb+b_pghgLpGC#QdE+-l}t3JJ1l z*R&!^{^qm7)oT&`0Vr2GzVvfi&LW)oZ+urqd&|^?@0trG7g=wk;_v|cR#oyz14F$` zU6+LUbyepvy{|wG$ohr%MGSr7wQbdRxOcR0vbw+=Tj;AWuH#B~e#yC3gW0c@JN#&EMY}+mhVH=E{rz9Cz6$je(dlCNQw7=SXHg1{1c z52M~X)13y*q;uiT*Md9hpK-qQZFddNwwTpTd`lgYf_!4ikd~QqyU1LMDO-^H2G^UVu3YZevfyZL=eimVuy zIU-f98GX(ee?YrO_40{f{n9eSkEp|?(1Azt8Yx07!Y0LW`;WcvK^p^7*^&jl&_oBD zj>s+_Y={Rd`goKuma#zVpDUa>TVa~VvW1A+T*eCldFVQ}qW9~?*|xZY(88ho#m;Sl zvebdAw`(>Q09#A?63Ea6eXt`O1^$e>v!|Yq`m9U;#+%1N*gTT&RS|b6L@*JgDqG() zUOp+l)H4KY$L>|hU`lKaKlXg!+xn=UPn7d)*QvZFAG_++Q9D;}Za9XJg}dpi>r(0Q z*a*D9F|j7@cl3`zF?C9Fe{Lze)C=<^bBZmnpA0OMcxKt)8QFZI*-EW;c4FAsi4%XG z$m$<6L6H!YH<)W$semhLN2m|4CAEnB@Xa%CnSwz^eFGj601b_-$OwqjFCNEIbr!z> zch^20`0jPI+ohIB78rs_Tlo|C5DNHkFrCP*gOLs$7FrfW%v|zM?5Q}KU9PLWJ3Xk# z8l`ckl(wxmc9d{mt0 z$BznqF{9`n9&?h3j?BVZ2?dZ&$bv%R7*GC`eb;e?LU;gv(s8~8K1L-{*yN29? zo^f7DQcURn_C6LByN(IdEQyEov&j{Y8I*IQVk-O7>_&8Fr|m%5uriKmT8gfVvx{I` zCo>d8eawYiS_X3raf!wUn<$ua!z-jmtMWha+K0tHTy#1y`*fCP`K>5bc8uK_xzBAB zGhkVIz=bSsN1ud;H`=17^ZsEZF*vFs`aXQuNHHUa)Se@5{&Zjx_%51QN8^VFk3vU^ zrRtwQY!~iqk6RO<37g_=oDtHNWBsJkjt09UbEN4^=qvj|II>-swm_L&K|>fFwDOhh z@WBwI!$(gYu5JXc#(xguGNn5VIN4@+IID-x5sSp-=$f@?z;Dbp&+znfi(8|Y`r$&# zC+4Z3m7F_9%dEtl#-TOe-Sz_bhe0$&ft`UprY0^t=GlqMjbWpl^^3$Zv6vu#33Qgm zOwPxorC64enCOX9eJ5kXmi4I?ofbVN#x7z;qY9{H1V+aTmLIlbeGax`b!oB{PxDkV zYVE^q=vl1ki^Oo$_^uoJf90sds{~ruJ!ysvu2-c=lq?=aeR*Nyzz(rcz;vL=au4HKGfDax8Fqt`IU@uF5RHa z?n8}Y65yZK1c+=%N=gaII-XcM?!?fMel zcDpV#3Y4Ts=qxJ(W6PWkrPU#PU~Pm#8bdT!xZ)kEO9pmC@;76E20m_6VxNH?U2x6w`q8b=G`E!0M58O{RoT{z50|J$jJn4 z6*LqMqtn80s;bGF_V$sM`zF%KuqZLs7v$e_&Ezx^PPsZ0+$?fKhazU0kJ%CH$Cmk0 zJxhX`0>~=afdk#z$7NJrOx!EnwAS6-X!t!c#3u6%_dP797Z(p3iVW!bYN8q7`n=+5 z$h^{(J>*-vO?UlnRjPfBN!ZGKICfh`u+CJ2+g&&F*kQP$Y&t)73I?)!cA+dTlPSY0 zND1~dp;rI6ct3W(qZ0Tvc{e^g|7a+$_!^8BQLX(Vlna@Iq-dm#+WYBRyF5YwdN~aC zlTCxus`#}p-zIpn=Azjh8a z85z%mRTwF1<)`dhL0PLW{8Juq-5zIDYbSV8a2;!K0=|GEcZ>%>R>WW&EDa4 z>g4lPL{^FxSxG{~Z5EiZ19&oNP9%QLRYWB58#T1N=uUGxq1zSS$f zE!`4m%?kSl4qhxjLJHsa%#Di}A<@S2L<6H`jHO1k_{WcC&Uru3h7wVHL;b@tno zjrdNhl;Ew7!ng)NBxy6Wq_x zTl+NHzl%4ieL!ncWg`sVs{PjV_?~+n_(A2$1-+6d_j@@O^Qr#fFD!qPAGe6DHzQ7*`J2HSu;VYBE+QL?OLL<9i=R z%4KWzZe#I|7TcW9->qJlQ?`n96pw>gfma&WWUTdZhEg3QRJWJL@DU$=uK>Pxbtl`y50@$wxJ?#$#1%Me z36&`1WP~{rJZ%mcp>_#DU{G-HG-x9^1352bfoOK1n>+iSH?P)mN{3v$#hsuqIR|<6 zX=HO6ZX-LYi!x0iZqsJoJ1RNd3zOW--SYVGVr8DtStu1(u(DlUY`o02%Br*qZ%>N7 z)PQv8Sb|S#d9t%e%seW5=bDIwIXGPaJ4IrK9|C0YU@Wie94a45G7QTxXJa3@KGV!e z*Hxs*Nq?M!UDk)vf19jYgA_l7v+w2vGTijTjx_K)eocL@J(8@&DnwHq(9VdQBlmAg zC~n!F5)I{>1h;bZt&{65e~4Rk?%jN?Fa7eG?@K)HiqY3EP5RnYuj@htS8lgS4L?di z*Rj>Hlf{ad-rYd;ZcFsK7!%?cUo*Vh=166%q2J9%e~&WvP(ACgV(Qiy)wMhMPYz^B z!PpZO)9PzGY9yjowEMs(2nb$$!X5kT#kEg*RtXQrMAy4Kt>P%Hc^+&+{4;`SHso2!CA4o}y?s9+V?~Nc6f2z*l8WoVWlkWU0^eaU49&dAj`9*UdVk1x#qKQ6Hwq43ZZ?3buJg|x;7L|VsgDPsj z{U(^&aDVYboQz?m!NVSG{a`iJ*AH)F@>V>YnJH6CWGP#bgLADHt0pTMrY@u6 z?apzL!EIj!q3Ddg&#{4D`h#jx*JiKZam#60Ppil>o)Q~MiAu6=_xO#qzFf<1G=%-t z$?^)(WNhG%+{}y+)QFr*XB)`L3Vp{Esf_0IEg%HuSKliE_c0q(GC$dHHiTlg%+OBP2GWNs3L_|mkmDq!qsf( zF`4~#_{(VWo3sK?8F-M^zEw|`mQDFz*w zz9Z+*I)J2P{o-{rN=xl24!s7{vUv~sV)HYn_7dy2lfOgkv#*6$yQxX*g2<5MqwFR|#16dE%gCjf%U_AAq45qj{@@tq+ zVv8MXux3BM-UKxDioCeyRP&y!wa9c|hDHjOHVIS^NJg@*1nW9$4$Sm|(+y1yk$5o8 zyHfYT2z0mOCtI}ngqKegesKg8@0f1Zd-L=M=y0^?;!$%kxBd>Z(;d`SPOGLqHlS)c zA81215d4X1n)FGU*V`28HaJ)KVaR7|0%+q^;;e^+v$Jn!D!h^leBeUMn!j|)%+WKy z_&?}BF`mkAxaiJryu^yV975yWm}-+f3+9|o<@h@|FO3F`px4ZR1|H9O124OU!!+@wlmQkr3pumY z^1*=|g|H?)U4cr~?z+P|O$K^JZ71ns>noX~n;t#2L6z$+$Z^l;5zGXL6)TL@TH3bm zZrHRXKju_1-dWo&zHiH);wM9ZQ4wgU*RXtgn_2IK(}w>#!q0Rkc&HUG5(f){?YiHC z@K5O)!G+!Id&+6Lx>1)X^dS3ed%c0>ahR6{)e0mKC_HaTHTy<_@9 zavx;Ik84kPv;vP&;nw9b9}d%_%hK!(X_5&f2ys#DHgb~|>Nj{4CRh7yV-_1RYUZOH zHnQ4}#z{#L1H-n}D#vQmS)XS4TUz*+NvyM8N{d@7?`VSc`|(P#_zk;XH!FofZs9q- zYdww*X|kcF%>HxSL~8iS>@Q_8I~bN7N=rjYnnPB-KMV?8{_d`;)m<(rVRi2@9RK2Q zw$?2?5GKqIe_>!>$7f79(|oQgjGA}HI`K!l6 z8OBS9-2Jx?pQ&(=LL!4Q1UU_>S_ia;8Ty~zn?w-W<_CcA;ie4+} zlWa3;CvRzbi7X3>x=Jc1DJdQ=C<|ZQg~oJNTpF|dM8n%A`#*?|K)udYtOt~nsxL>) zxs&-xPE?XKG>VpNr^&~ZQMdH;m0bw(w2~KM zefF??{0{KZx64~h(n5SI!##8NV>=BbH9(3KH%kTn)a;nt+%58~iLc8wM~;HyAl|xP z=S*0eB8TNON7Us$Z-YD!(AIu_>dBo=Tr2i3yScLEN7Y++CJlc!s;%iVuWntsLCQJqbi`u~_TIYDpk z=bLm_Zjo!*-@DoB>V|;s%7S`2(8#+m`p>wI{|HM7PT5QY&C_@Ct-TY*FZN5W)VMDx z8Ff%C>-V{8Mjd5194p!Pc%Hl~=y;x9-(mjsQpPIN4sURNSp6#vDu0z(10@yHKOLZ+ zHy|K-jSkZ~L7oEP)9xO^Y|ggiW0<(EbSe5mqoU5l4s8dBiNm1K;_7p-&hQ6V&$HPE zx{IB1W}n!n>(QwyLcp5zi3!qKjrwGO1{8IPE62WZ0KBvK{GD`vypx~B#TQ62^V#JM zU*8I+Hhv1DW{1cW+T3_YvFsUQP+t~z$lE=^sr6E+s{SNx?WBy)kJoT`W;*eF;FQ`F zFkN{za3Vh+IKe>Zjj+l@&!w$Fy5ku(+w*}FQT{mz-2M+F(0%_e5?D!dK>|bmU=*j3 zB3UavW_86!MD^7EyJF9>^q4$^tOV0N4NY5&*sYm3Y-IeZNKS-3C`J#_hd*2(^oDie zP}?B6d`j4`^nwkbd^hVG^KQ`Y8+!fImOpbz&-Hp}8}ju6ug7PMsBSpBg~Jmu(b4hSq^dHP)-Qf zNIv_z`#0X0#(m7%@`IlHANR4>)iCApE*8NMGYB3~#wdZ_U|JoPXo4Zq>hf?IIm4aEGlchzwr= zSC7=!xjS%%ERB#}?kG#!u4i&IR(PN)64k(4WNY!pOsmG<{@g!JV%z@8pU>KAbv`K( zCN`@pKZ<4I)8`D2h0lKe0roBXe14}l-0FpS671|u35n^u7c6HZe2H}Nm9Pnvv(pbt zVOyrvoeAS1D={CL!y{Z7IyaaRpc+=G)$HQ3UogP>(OG z-(3gF@vS&_jj&MuhlYn&f@iE7EhZO9j|Fyc30usKSo}8wK%F7-S2EhK=kthX!rR8+ zC@$(-u6cq|T-Wlt$+u%bS#mHWGp#Oe^I)Ef3N5T9_hLkPlvDhS=*!MGR*D3+KFh4{ z&xWK$F%_cI4t`i?ed&#PzP}a+sZ}AmNnzD9-rs>k_NF8iB!H z>{lIE*aKQZeuq9LK#EzfJZ7b~$5o2WpT+LDqZ=H5Q4#K`Jn6r?Ei}yk1)Vx|H&a50 z+mwP88Z*K#H{B5WZ`fxKnDhZki?xN;fs+^untmc+{2epAFNE%^wKfop`GxvuJUu8o zZTFER&7cHQXa8l6!`5X%c&7Sx?0Vv0A2O)NEMT%evY7#saO!JA7&7o*7#ZIU9FJKX z*nmGLPAN$j>*+C3Wd@PwRpt5XTS|ULvA9VMfA`3+CQ(mDF)n#8MmbvB4jU1dp}c0R zX(?^U>eG>`@hB9kdqruRH`DLL8%`hPjK+mn^rU3b>bg&Ib50L*pRI@ZnF-lL%}lxL zV2rgD;%=Yk7B;Q5T*R&_r3=Ov^>4;E9gDqKpT-88pIkTFf4i(4ikO-VF;H4bnElc9 z(BeL@Yyh3Iv)l)6=<(+_^rwH^(9cgHomg=}!tjDZ>ySkP=xv_#w;fbojC5^eA{P%T z@lBDH#P%;ygNh!u^7|$VtKo!Sj>=GfC#LB6+VI=ArghFPAd>To0cVz+gpJI2)f$gX9wQrvs5>l|VzTXb;ORDglQxE+aH|>86%T%$hD~C>+ z{Sceq()f@M*5_Y(pm*=itLt|yj|gzzKBU&fTl%RBTW*p8R;I%2=Ce;zUozjFJf3eZC#>S5urvnpArs&v#96hL{^{-g6M>7AkD^vwzR-{K&65I`)vh+(O1AwX&nTF!uZ_J@u2j z85*V1|A33NyDre-65G+6vbP06z8InDt6}9#e0fBLd{nB`Nv5*INe3MraVDL1?t2b! z_DyHho8(vJ7G<84>uQ|s*cs!C)dP1Lnr|kB$G5$LtqR1VUYhso=uzQM7uk{x$$V7t zCVCcvuCYv5g|UfT8`7Eamu_A?C~b>_Sn8756~Ck7D$XaldCh4inD;koqlf-9hiR)# z6Mi&ly<<84?q!|Ci!{#Vo>>+$@lp&12l3J#&1KVlV1neH<{_`|h?tDvm#LOOz57VR zWxvet<_YqMe(~Hh8Zon9+8X;kwxRxZgl{5Ix8>N0ZDGO~s{|*9&ut~T4^|;HRgwJr zBk~39(0yw-5&5u!w^2dFZ}oCRDTvcfoSRAUM9%gr2Yx2-=*)(1?sfUgx~b!E#;_Zk z6F8V~VkNCdSCrpzt-wupFesl@r`(lzv^V-)T*r1|8%q!C8A9ehpXUi{Nw#fxO(8N- zG$Wobs?%$?o(w3T;s(%4hhCY5qTwqr8n)_WbgOl|#k{Z%=21SvJ;>T`R+fmaCL7Bc zl6Knj;)$Rlnhheo#=`z*?WA|~SMAjQ&iI&^^Q-)DFxA^fL?`+%A%5}8aWBg!I5wRq0&Vm1A4Bmdn2m-mPF<~O_8>9DkALFHa9x%pqjPP%@mpb zSF?AwhD4|0((JXfa6gxrpX*`5o?DW$4sS}=B}qR?fbIy~cNB5I`*6o5{#7C+!4M|x z#Y)Km^{|deD=kPZeRm1*wy8?@I<&9}vJ#i4m?p=x6{X#A)~H!BF`r6>vPeqp_4&09 zj&$fshu#eHcxX1|dJcD*{a;Q5YTJQRv;v=XTa*i!9j?nD^njD>;{wqXMta7RUiBLz zqJXESud6sIW?&4jQHYxS_b$@Vp~jXLM|scY!i4lj(l?`uxp1HHAHVYpvjDO6MoX`B z)>Yagy)H4K?8&44ii@vIAlL!eZ>?dN9p;q>_G!t2S6Zn+T=;UVk=mR?;>KNHj?B)K zJf%Ai*DkZnVRpfo%hmn9PXU1j@tlf_%YZWX$fU9yS$ERy0Ax={$UNgr3TB;2!Su4~ zZ}ilkN-g;>i=J4G?&mAexXLZXwG_T{G!78?xHDRWuuRvD8sSTutn3Vw<2L$shyc{Z zA6z_tMK0{LY6nnzb}_qxvXI|R^teM_VM;~@z~z;s^^7;|Cf+JGZI%aNNQ8?Ki(sEO zQ-P&nx&F*}xz_?sZ(kZCV~8JwsQKRLC0!!NCANbjs9y=#Ric-IaCU$`YVn_a)Nd(v zx$fef3E$x|6)Xw4J?wiA_eaE^*UU9!2|oynOyGzJDHO|HGtT9cIJPpOp>F zE)O#ct*pNfGwTuN-h^|O4(vEt{;{nDuymWo3OW@R6XLrtQ4bx<3|n*?1|m0|SL>Xw z6{#8IL#z{th>z>;Ojv0vol`o6zbV~ypz|lMli-V3j^sK%3_Dui^7<dVPd=;>ivh5Py7+DS3} zArfSqc(z`Z-CJrk#I?vA>B$(Bkw1kMJSw8l~Qe&L$cV1sV$3#CS)hV7}?1t*Du$ z$?>I1&jM6>HP$cD6Q>EI)^Z#56PJLbT@|OQ`ru|w&u3r0pN6r_$kBhq2qQPh|oqI&sLJM+cIQl6G3(FNMwC? z9EJ7XzA)vB_}PLXX2r~5xQZurK*nka1D#Jp@!f8u*DhxPS4NGX*!I!>KyO~VSU)9e z2c$6P$YL3O>Ug$-Wl24#D8fjF3p571fW{!W{Ikos;sZ`LMaeB&v5r`g&B;29o;K8X zwjT}`y0(hBRG^)HWiBhM>3Y0e7sKE;H%w?tJc6s%Nf98VoT#tBmAac?o{GEVQZ1KMcoLu4p^|(4>{`liuwy~s+JEB&(9d-ZE+nJ z2Fz~0fA`~fzXL?|O!Yy|RNr5>#NMK3*S98Ws1cJ(hT$C0@WX!zJJ#B2_G5Kg4bW63 zBZp~y^}3zTi?-k1sLp4;u0xFPM!My@khq{I>2|Mo=qemnlNVvPVqG0MI`1!ok`7;; zi@9wi_~^IbW_*#{VcQnl`X?s<1AicKd4Q!~Q$Tn?JT*?(>rXLq1P`f%JCP%v>~ArM zdQ^*v%DE{~#Qbf%)t}U4B+PS@#!^PvtZS*@O7l^No_N!X&e?WYxt=nN$tUl3fwDer607fp>(QUIHj_nkk=ZkW%eCDogrcZ9x_?1ORd(JZgrcD3xokQUe94Zi z@lb>SkpIwqx$^CVevR8ztXE{fRb6pgBlP6>1R#9+6=1zLl_Qxr-8k_U#vY$^o18W% zvw}@z=e@!oa0zT&lx1#9I+AZVV6x4wiW;HdT=JQB(w#>Kajq5Q(Sr(g+<5vsm{uRY z-}xeyN1A0N7DyjItq$}ARW1B43lm_eYC6^msK)3+L;W0F;hcO?0=V203m_-{KC_7> z;;8qLFPQ=aus2m5AF_w6HcUT3Gn|d(PzfNqs;Jl&mkE=CsWtSH$lBSv28=^g^9ImF zeF$Y;@MbHpRu#f&ZYMf_`5tiDMR1ova2<#mhx*yWRn1)9hUp{hhO?(S*?6wE<1Elr zeiNYF5}zAfs+V1A!&=n{*S?+T68$~quQvk$6w<~6?K|w|B!~yT_cdEpvZGi!-A4ke{{BIo&TORvD1HV3$|{dWsG+Sf;c9bElI8I8YBk zlj_mGYu;axyA1y7O0tsOixNFg+7v<4N+3KnVu@UsrerkOe+JOKRDkY%K!DVp>eiUm z`6)PLCuYp}kleQY+vZyLNT@ZW_nJrXUdeRc8KwoaAJbyksP!?deC|l$ydn;9^Yyak1(^aMW>^hGtxD;=)xb1K zLY6Dx`}8|sE!PuhHr$wAS}PFhHxJr5k1DOR8EaWWAFS3vYX_mVU&iHLM`-8Ny$1W6 z@D|jzuLiLzl^=&hW{O#FGAQypxj5Wx6%C0~HsIQ=&HOeF-KzfWHgVTfO{oM~oCW6? z+6De17pAYKwNxQ_CsCm61)fMF>YOJ29C5b_UBWW4x9^X4V@q*{Ga_%DW$4D9}@5*$9 z-9{-JK{j=Lz@Z!eGz4<&U~Ecpq*@N$(&R8z)yh%&S*CwaSVV&w1qgTh(MTjtDH%zZ z+u0qT;6_0c#`MHhGgh8@L3X^#X{fn&osWxpMr1|r%c7EvmJ(%peRihU92hauZZX5Q zX_rs(eC7s)TFOq<4kCDIw-Vt^QI46`NawD{3*t!H4ljevwn_?}CY*%QfO#yl8|(ev zjRZ|(v%+Le1sJE0EH31B>y;xOchY0#agS~I)I>TCbg|nGwwOBX`KaJbL{qaLQ~4P0 z<_jfu>AX0wewTqwJ>VC_zc|WY#s4z@SRkkAR^hGsC589AsDKscNG?yqy z3`_2iXf%X*kokTGQCG#rPInm^*gubFlrGv_OLfj}UQ5-DZpL&g|IHbI^N}0p(MHip zY!6)S|&hiGY`8{_HAC0OQw_v@o9EB~kWBS-gE{{$1HKyP1z6u_VCRh#ut`upvhaWtr( z+~>!YiHxCH$q>FT#!1Je>fc%AIkUw=k#E!(|1fu?LKF0~mZymH9BXeS7un+ePUzRB zvFe%HkKe+ktG7D>zP4zaE>3H8)5jq5^GVT8)9&~WNCy~iy_9E6v-?uwk}FD?KmmM!fG}^=Flc}D zP%=ObQoXr0sTp+9!GdY>9}{q$*}dKAKmws!0!C91<9u-m1Gd#BWAt>Oh3(|CV~0($ z?^%`Z1eqbgP<;|dvl)4$8A$4}&enK9Hw@ia*j1@f1~+S*eSId?iGgES;p`Zm>5{D2 zQ8AZL0lqujS`&IU{RuuARzmn8OwHKFdhUr)qx{mIAb;a8RxQl>CZxtof~?O4r8Cv209T85w+x&a4^+LHOE>?Fh+8y3H)`qCXu zt+MY3sK3dVNclmu^H6@*Gt zY_ia%a$C@usxNeY&)Iy$g@`AAX8fgVXDh|M$A_3V&Kt8r-|osEj*WE%MDV^Wu6M7T z736%-_|s7CJ*w4)_`lE}tF|zx-GhJjsw6M;^U$0})Vl=K;yn26=MQVJ21;ex!viRXi>3;-& zn>I)bo+Bv35ZBbM)yQh4+nDK4nFIznt~7YQRVI>$c9gcK2s3V#ETx}u83}BMoA!7F zMaO20+s~t5ZRYC5<$YbX|CpKtvyE(1N4K7#pHxtz9h2}}Ju0bw9xZbH+6ZZip;UpT zbXo@2j}N;jJ~7zLEHZV{cOqo3d$@hw(gf|X3Tx4#LtXs|%1eB@DMn-#d56 zZ|c?Y9mEoRo;h_-S)WSg_t-vQ*(8!?{v3QBMRv@!F4EU$rxOT{`_$ivZy3t2Bh6X0 zFW!*z^COsd*;zMSnp_SS9e)T&R(c9FNX{d?yK4HtV&L~MXi+>a)A_bL zeDm=y(37?!B(P^?cyvVoQxV**x!NP?qYu~=Km3(W@aQe~fJ>aLmZanpuH{;LKdN^9 z;1tyJX2Ma zmE;=&xv_?h?vWo={C${yeA{4M`OFF4DD4A$-^WRD7iFnGuL!}1yRvOJTH3W+vr|3M zlY+i5%>joh3S7@n>{TbGV=iUw+N^1fJgn^u%s|A&L+gR+i0yCO=RVT6rBi?EEONL& z@!T~3#@XJEUHtpSPhka$dQI@40}IpSWXHgQTX8v=TR&(U(_%RUo@)ZS&l1R;u%FH+ z9M5HG1r_~~oD_1FoOHK~e<1e;=jvt!U$7E}*6gyu#B{Jn+CnHf2V%oDSY00FDnKe2 zRBqyWVy0?mS;?D&J-6xPBc-q$ENP&(>UK7=GCvzxSr1do0K_lZSX{~hgD*JkaOX-+ z%zigzoqncaLKxaE_@th7s#!uLS^ahYYqx{~DWC@%%!OHn%dH)W*;p8wRNm*9{FLG{ z14%mpxwPw}L0rct2R(9EL$zt12=cc@>wrRR=oU)5DV~t(aLtb*_xIxZ2(I8OZ!MBQjv=X`I(Hv3vPpMfHk)$g@$^cW5_h&!f;s=3RS5 z9hyqQS(L%tcoR%^oZ#0sm`#=B0c^DoHXw4vv!|H(C^B9KDs@;+V-Nh!_arMeqT>jF zSAuboJP(SEE;wJ|q}`q~7xRF&a#Xd^VW+tFWp^*%m6xO5v|qJPFuR^mEe>8cf>6i; z-Nyr!-hmU&ayG=@6&cIgsbUkDXaI7PK2qJp`!AmF|C^ABoiI%H?C;NQmkVntE@D=I zjaqeV^#u)uA?JvRrO4Z2aSOt+|33vy@Q9I=8N!@3t4oE?tSUbX>gQ6Czyr4wg5KNo zZ3IVhO`!TfgU+o&Wc8ZUU;^X-=;#6KxVBlJPq}i|a^s|T+-Z&NKIeGZ@B4X1xt}_1 zaGHT-XIk9$VZ|psXTeEk`NxC9^wjTwhzrg1q*9f$@FW#`1a;a2mLB9uVI)k`sC9o@ zGDk3e%5^{l;#S}QyT61KnY;E6<7c{`7f(?F)v^?rF@95mW+_jmmJb>VUqQUV`Lenk zX9adg`F7&bOODEp%7M_vKOa_2Om(V&C6nq^Pu_AL#I3$Nnf^vHr=-=|)u)%;WJt!< z(s*4QTM~y3-M65|diBsvy4j@jwQid0tA!sF)0xBQMig>Dg~0@|TJ&%u`#h20VU>5< zFBr>6F%Hcf7-y(7CcO1prr{$lTG993BbTY|N{wd|0jj8AT|WC=W)!yg!G2D)cDh4G zKEKis@l%%Qa)!T?mEP!mQu|NlFMFTAhc7vL*WaCOhMm6l)u$Y_YlJssmuDOOn-55I z62v7@ac-{a}*#BRA>Ix0+0d#ueU<5)b*%_%UDZ<3laNWO>L+M zG1i7&n@n?Feg0$48`W1%(z`{y-D?_Pc+HL)Vc$ z=CrtzYTL|+s&!gxuP+7}D`31XaXRmIl;DdI{BfL-*yA6nC)l07Lc}5$Bi_9+DndHc zO#c^j=(+y0zx!2ilbBm;p1%HN$P6dUIMx_l<-NM3Wet(m1Yb*mh&1Vys*DC~$Fv`L zfQElwc<(78>&0lKY;+oTgbJ|m*+YPZ*9{x)yQGFuXtyOyLSjdJ|0Wh;I%PAD0o0U5 z^lf;6NJgS_^}uMwlpp?IGLsy(!%QqpOp0pk#WX+t0FN0+tsGU!z*v_U?Mj=T3i|JG@FrAW=Y(<`dKjA>9ZU#@iQq2(- zw+|`N79frTD>0O#wDL|MN%Gm=r6N7s%l*3l^6cDNKbr7K(&MXhvg0YOEwufJ%HmZb z1_Vm3sCkYaVgvxk&-176Y60*!tZ#dDY+XC27Ke-3nu(j9JmFd~@hV&>T+#AtWEK?9 z*;I&tqib#v4-eJ;Ti*GYDEp5wkrSlvm*A*`9C2Ogz|#5AB~*Uz^f<%imdTb89LFo; z4gs2o9`IY)!=Cj!n5zt8y*H$*JKvRDEe8YBsju8YTkj@LKbb$NcQ}&y#bnEni5}sg zOzi)7$-nE*h80ieyRyID26+tzXMoAEmy%dI(~UlFMU2AI+Y;UnqC)w$ zinNS^&pdk1MPSlI^{?);bcqGfSc79;pWHr2xNNs<6XaZjqqSjicFyHgi8X>U$d)Ko{h{Hje2~Qtue_QJxj#^Dx+Noy=$}U z)nTY7FGoYW4u#iJEl1$e8XrYrWWF|$}{fJ0`))K*8;w2B9UXHcGO8j6IBe{eUv3E1mz26ZMF>-J5l>YC-p5dlEWD@Xk_aZ~ zw@oani#Um?+Jv2+LZp7y`sw7R1m-~;olqV*s z^fP$N{j|>*o<&=aNzZ#8u}Cd9ti$0FB&@(;Mn&UKXyM;-ulz4)5vwNh?tI>+%wxFE zzy4oNE|lqDrg0ttJMj+Q6lInB2rR`JoS)}arAsTdPW<>G{6wmB+7?JqBUHs)q#lU;iWM_3`D{OQ|At+uM+MY~ zAv&z)dejPV^OyYR%|AUcz|tYZV_f58TISo`Nf{%e61FW7t~bjC+V>vJJ)Zm2$M;Ks zu~LeCP$UOsu^>n})yDoJ#RaVKxR$WyL`OJotIFn$!W-YS5Z!am+T3i21*^l_g`H80 z2+sdOEviHKi=SqJ9i!_x@Rn}?P_gT``noJu7!jMSfGiHf{g4*ZWXHVSm89=tx6|5G;md<^ea^&Ft{Ph$uL~J|zxiS! zzID4~e>#O!xP*|oJ%}m%H|KmsjNAHdR=oU1Wg}KBdnTo!O>8TZ#B` z6@(akxKYbO(dH>>*3(S;3dtY;5`z@JQ5!#DH0I7q?aag?8t;wiLtSO`$@hP;7D{z3 z)2%uSt3brd(nX#3JX2c61j9;YCutxn~ULh#rK?n^Q?(5 zDvQ+{nby63Sc>)752g}ki`Jj`Wtj5z`Ttt$O));D-+UuyY>@eG%_@UL_f=REzy`Nf z9sv&{r<7S?+rt}zU!^~9ivGJ6GZJgWcb-s*D!K|wy6&d<8>9JT(3uANtBSxYuSl>w zub|Hg5S3H_C5kzo96dRw>ppq*2>==Vb)3hPT<6GhuZMd+qe&@q;~~sWKERA{dKV{$ z3$nAH!YAF`f2wi5T(xn&TqX9`a@8Nyg3*qjy3?QQ0$UJVVvDf9u*Hd6eNgZW{qG}} zeV*gQC*)3bYCvTA{^V+2`jd}d-M6QTE7-te4Y8H}DI7m>+1WP_V`}r?V_igZUCUy3 zUDT^lu>CgL+{WNAL$a^6ly_qtpzFf!0Fy+%@G~ zZz}7ost|n$eO}->q>g}L%N%%P$w9O6S zV^@Ze)EbXz-`sEOqJ9f1GuYvmIm(zaV3Bz6dH7X)*+d3)O@P%Nm#!#o2ZYdSp%5B7 zQwB*d`*lh}5l z$wO>wocKS3;Er2e0iDBo=q;jBTNV=@zqjeo9)>q z-`8I0>bxs#AN2xjgHIpfbl905y~@xrTrJ3mBV2g#Q&00~o$0%N?7WiiR9$5u3ub!d zhP6Jwn=$d+58ld#@&uO`yH$Wl*01}dA0H}ZR{bVL=bWBOJ^UPXNb@v_i;K?FDux`L zw7tXO@KLcLv8sf;cc3@r({sdLm*gWqqY?RL81-&>193j0mr(cqnPd-7KLo*!OQ(F4 zEJj?Da@8QSGa)$0#VO~#8-0r?oJ`DQ1=G0Yt~ zvIhJ|)xtR0_j(kVm}!Hxfr~uVoYhbi+zp-=5b4oD)ka?ASqs?IB9^o9g;uhEA332u z)|fX^z*LL}D7#yf@OXPbLD+BLZ~QL8Zx?vHZ}%F?eppS-OF@$`jmCv_4ox|6mO*`# zCD6e#tXsccS)M8!63am}MXW*-%U{{5soavu{Z`4UtP8BHT5L@101n%xU5(oB_)S?~SMo0oyRi*~Oa`yDM~x`OM_cCGkzjE~wGG5m51V%4J!6MnaxOH> zD3%raDXvVmra6xRDYk5uL#&QyXUtYYgnoGv$cA;f3|ZWhrY}G2)$dlYU71-bpK@T+ zt{T#e7kuEPBFD_JQeFYJs|;$MI57+TSFh0072ET~Y-I4w1R_YzhNd6IqrxEO1)+EI?(oVKnxI6}h9&>o&C>*jrBQ5W`^^Hq>&8vrWVBE-*Bc@O9 z+qw~X$0*-Lmx`dTI;1CemzJI{Do=2Z!Mf}jeAa7GiyBk!>D-q*kH&_>#5;g>!H=Yk zU~{-yq^cjbH$O}4J6oiRUEovsJF#yoh~g}XR&-t29i34? z6m7V63|PU%fC((WhHXJXB2`D!Nu9#mt;UnT5A^4h&d&seKh6X|{cQtnz1$++?*Pw5 z@N*Q~b!aoZ8jl%s{rT`&qfjHxv0WA$P#py}-LP6?-ex6#9(4I%exBJ^+{B4F)pDqm zv^{LY@*Io-4a>Tx;s-?by-UnUC_K{mkLWLFbsue!)E<9hyGz^h9r6gz(xYkj!w#fz zb>=V=6a}?N$oE}$JwJs^lJ*M4B~hDITA3a8OijME?YqSQc5m*)e}5~k&gZO}8b7HW z`H1V)J`s}-R_>bj{dbnSt{lv`2bOWM-}_(edUZMdxRSK(7t=MEvC^X>&F{w#HWjjk zOIxqCUZ2kR&^??HJ?~+8(+-;US+z3bcv5kkq8RzS_d?#0iw?EiKPt7MsT(n5vBH+D zCF97znwY?eAH$!~I0fpK{L#seR2pG|`D0G6E^YZ>vZ2>ocl->0JymAX?m!0~*3>1T z#VE7N1y^pT&ByG;Zgx6P8S^GnS)QG}aZ2FhWf1#dvO$Wp3XMUIz3VFRFb{|EV7}`+ z=2pkGh$i7AO&}LAvXva4_bL}qq{a+ZXx3pMQsE`iOgf>?en!=Ci}NY{5~~ru6ni&y z1YRIW6b8z4?y@L#j^-)=aRWpfcMIQ?a(!SJJNz;P2yWBxH7 zsFoa3>Ovl8Rip%}K2jcEXn=m(#hSYc-D{7iGx|^qi7Xc6-HbzER^fPTtaz)o;F6z- zz0|-?nS27Mz`)XZXnLkHJ~0=Biq?p{-R|%O0MSL;QPx9QAP}hjMN#Tq>LZ+2lo+S?>UN2F z$4~?pZFKIFhRbHSPN;$8F61+AYFP_(djPyewuMF;{Dk)fYTwKo% zCd)iVtQVg_lxsJgteovQ8QS1+93{?!)3 zjXowAEYp@+$9{Q5;!+!gV{ z(;n%QXiQ97I4Y8!GOCptiYD8cp?KzB5llm96F zX;!7du)gHii>Dlb&vjq&ISzo&b^podzFS2jc9B3xdY0kk<1P=1u`2|0Vwdv$c8dy zv1}G50eAAh^7Y#HO)k%z=h$YCtAP4vxOm0&$b4t-JTh%$uxY0vHE(k$>0!2&^IbZj z413!p8FvX)^RaEHYl!-w>6LxtSZ_u4xKW<6<#M^lH_jqRvDY?d?tER_sO15FD>}|` zTX@y;(3#l~PqP#2XG<8_X#A5O7`$6gC73UFehTsQfg}qMQFQXiti4d~fs1Nw8=c(j~b=Ho^|KBhAi{P|R6>6`*|@ z=d>^S585}v$*pik`xa^&Ws2aOO~dQ$E}73#_jFdP(BA%po2N6JVp7zzSgnVU3qle= zO85S@c^?y9R1!vdauPk_5)g0r2+G-|bq~?jir+4jnR+^|SY+h;GE`*uF!N?EA$(+! z3PV7!5T}w#ood`8iWW@MnrrL+2?CHE@)oXhnYZ=--sL4n?PWlY69qK0T~b=FMfZJO z)r~BD%At2UAF86tt~S&G$%0tO4W&3}eZKsymYWk(za2PDu#PJW>_koZr-5Iz_%LCB z*Od>+7p<%`@*+~=3c8VO#TZF?jzld|UUT3sn_Jdp_H+-gJDelft>^D7$;aedC9zW8 z6Hc5qQ(XQ!Q}56%?)dopEW6^;(TQ{8c@z*C&&*C_8`ebg(0aFN1Lb^8kNufF$A=y$ zw0dRIJU6gxaNtEffBoYnXjJf*!d22WAW*N2&o>*j{(ze;aV&4#5$cpu1~Rw~+GG&m z=-)q@x(x)p#*&N`JI7Yylss}A9=@}exPyJeZ3T_BOmiRTd%F;t+a zC9-M#y8ATyM{b=|uvwW$p8u}f8uA4||(bB5O3*}SLSso%s|*cN}xts3z(#1rbC zxdWu??KqTB@XarH8|h)Cy#9no_hNTkK!7aa0b~0KaSi$Bi%`8^teaKv!8TQkn%=PP zP+0dD``SHQ9wW{*Bl(RBpNadzr~GwAm&0RlpU$MiNTyBcSXBFD%Mt#Fl>pbGZN?6` z^ZKwS!^((fud@DXsnp);@H1=jw5hw2Q-KeNYg_SBxn9qog##YDZ}x#!8K>lt=)Wz- zL0)nS*f)RUB@J|c#ija+ecM{4N0d**&wWJ0Yj?;{^JyS4w03#=u*54684NeEbI65@#>VMMo#Y-nsc{P14*q=B$vl~ko@I9gvvp4@V-uF7$OKA6MW95S zeg?8aKtSqhRI0^s@`#-!#5lj_!A|HgN1T07;crQW^;XB?Sbe8>G7%3__$q zKw6}8=uS}@Mr!B*BnB9Ir~!sK&k*X~pS{oT`#a}%UFZDkHSfZ3&;#`V@5WxpQ`MOtAzZOISTUK&~Hhz5)H)*8do9nb_DE2H5bBv3$ z-Gu9>f>kZv&!ctWb{n45M7h*}(XZMgVgH<0z6Jt0Ac*pAhWn*eG`8L`siWvzsfFSQ zSq0wly|LZ0w`e7@NK*>#4vo)2@uDc@1y#nCeL?05L=(ta*G{$X^^|F@T~+hi2lo^8 zKg#_ylgYmv>=E-16d%=pK=Ivg-Ra#v@3w;0Bd7g9v&XbnynWsS>xbTAf!@Kw{yO3z zdKg3ETX+|=1!rZPc+%V5wPnQhC{<&`!!;rbME4`qQCsd|(n9TOy~bz!OP6_XJb10W z$KUFTyK_U4(p});v_WLIY%l(+qLcFwDLU0i)Kl=gUT=G{=yY(D=~Dd@heq)UK`REp zjTa|rW*YQ57AK%tJ#!hYmNX=l>8P7hS3b}xKZsLz6PnI|e~jH(7uG3RtYsXl(pX8J ztdN@iFt8Fz6R}ra*Yj;tc@VPY^@6>9d|T%=zO?K(y6Q3L5^$N_om2%%+gf{X?o{HF z{dVlSo#2s7aDAg~SYV}8W0rci==_KNIPLCw=_P~QAz!HSUmQMnmh1C?wJ$Aig+F51 z^T=pOLc-OAJ8ywa=3e+G(Qy)n9}`E3g4*D#*6&KSD_mDx7bkAmS$zD$VALJ>F-@lN z>Lx8Hv4KV?8|BO(VgJqp8dV13cCJrO9_y*|8rFWYr-qFDR_8=FW=?eM0!xk(LWv@p zV<~;yl%2{1G6FiUXF39|yXelE{hh2ti%@m0wNVOAp0%T8c?}x3y{p9O9LqbyL826a zHlw%86(S9a=mRQWFW1ZE_4V&TUFC2aHanpCtxVUboFel|YCGEdRsZ3^gA6s_Rc&C) zUKsn3sFi5Svtwc5G<^|(<9uqv^FXZjf7rGMXnKD!_<9JFF*H3AHx9x%og~!Vcr8rA zK{HZCTuv+x3_$eiS765uJVU^N=LdmJ$*e{}L&NFUHkW=3AGcFX3!)~yZ+IuFxv%{Q z{0jK*%Ib(V)YN0_xvP{#*M1b=8cGyr_-H)&1Lz`kTygeM*ISc#?0m;wTR#)m2lcm+7W@y2?$%oGE`mn_%p@i=U;h022ljQx4)xQciVKHxqAPh zexf^5k!R8oe-N|h0Y6JQnEgwQpCvCmFx!+BLY$weFH8CV%zWntnC~I^Y@D<@0}C9 zhfA(`vAVGcMU}*}8v3aFhIx%}4>%x?X_4Bw^ojQ^~z+yh&{46>XT&*vEX10 z#%}k>S>c5W85=1_<`c1Wo%JzqHmmG<6fp~XzD0ikCI9WtS@UWq*`WX$Jb`w3LfiIX z&kCD#i*!vvI@OvQJGZ>RkvCOtviFST=KKD|Z1>@ve2bR{Y*%|?ojq7uOwPK_-YwI9 zWy5%u3>#W+=HGSBS0_pcabfeIVJ+LeLM)WB?kFgsS@GIwufaRyKz?OmvDnRh^e*~^ zxccz7<=#vP&ZWCLIK(}wqmkGGa)F5U_evt!j=n%RMi)l`<#CVLMp(Ooh8umr<+`)B0I|z)aaaP0zmw7dE#adC5V15 zrH>uu)j%JZ3tTt>&xO0;29Mm)(L@8$f-&{GDPzDoZ;zy9{OM%iL0w0$^t;52msXC- zG(sy+={7J42!{7I!Zu2)d-S7T+6}m7Q-jvbQT^zqZX3xRfCU9u~~ zYs6U=t_rVP^;QvjPYgaoe#BFvoHJ`d;X-Y7GmMZ8pPIp`Rso`!M>v>;(_HKuoAK*Z zzU@3(8cd5^3r*a8^xg@cw@m^>1rQAREOZTxkNv{L6vldHXk02>*tB;iQ9Lu-B}LA} zgv9T<)QR=9Z+4&c*9y$yk|;FnnPnG;AEw~zcdD=D83=v8>m&2c?^}N@%ytaX_Az4? za4Ymf92&$(Pt9`BII$TdXzXg8_F{*(F-Z#&EVijJr0B*)kXV(LBj9rI*~VT*hxzVY zfM6yEZwgj4c3zBvB#fL$GS)4L&hhfSOU`myJ3z!bVvs1$HD3QXLyEc%SUY zWAVQJ|3UgioziLg#SMehpAQ#5l93n_T%|m1vEA9l0(nA}@;zm(tXXmO>05&z(;2Ol z7?voI&F2rLCWIWJ+ET`LCKj-~?=6eZd#0Mjaa#n>o2k{5NuB0jRPUOUC0TD>82xey zdExMxjYWp)9X+cr;BGIwDx?2({)PAdyZnm@`TrC77de1oVZ_0D%QIP$NlnOi@7}=r zRY%eU zhV>pM@tLxI|K*%$>%Bx9#W&fTYU8-?;gx|F(n<`tY#sSk<)RoPjKj8UqYqM}`AKQlviej*_ z_Yl#iwGq?!)Kd5spnOT|Kd~3Q4A!T&G@&AG*n)te^%&tR=)H@)n zMreBqam=}_^w`vmdZ}(q`Bp;cv*`rS2?*gCkg8i$HQcINWA=olo24j1r3+)KbGvww zaf!8vA9_|DYM?J`FtCSzs}AlNWk-|qeef>6+=ygo*E22abX^{UyAu2hC$yOQ9{t#t zqf&$!Bt!V8D1>8E-32R4(d{~U$8bG4ll+VRHz|l^Id72I)1cLX-1J;Os0e@p%{qw6 ze5`!t3~-1_4Sm6haxNVg^Q*U}o_n>)9%q_m_T|=b3A~(0C*{xR-7+M|cvEV{@=c+K zZjK}B)bU{Wu8FYKV{sIH5a+lKk>px&eWmyMUq?#}4o0pM(jAF4wIBKh^{W8`VM6NY z@7H#VN;P<4j&dH9oh&i~s#0Mwp;JEQ3kJ&47sRuNUfVI9jWA%CNaix0rdi$?R z1?DI%omH)&uG-~p>3d0Ioc~S+yEXzqzdj4XlEh6M8j;mH3IbKB(&We^d4o2*z_jJzv)SF>BN{C%wOC^Zm_HT^`j+jt3q(;Dz<6(}6w z7uu&|EXu~P)EOUJkVmkP0%1E#7hX(4AHLs(t1<uS{>5<{{p67b^Fq z7ras}N|D4KXOosF&j4F8jjVSrl3!<9;2U>g$uawg@eljxoFL^aGN1>T0wK3v7+CRj zArw7%@yDo!RRi^7E=KRNT-XZ7W zng?7|yYfM>FUgj_Zek`xSouQ(la#z1tM#O=Qv^P!wp!~~EA*u0Zgyo|6Y5pRiG;KJ zGt0eZdG^wzrS}@LkXkE9f6%MPyWZS0YtPP?H<&-l#IMT<@4TO1mA-wT@N@p28g}+3 z0eYD)jS4wwnM^*}VvB?^_>CG5EMlDEUxIa4rWJJ{6;=2vfc^W@nxR4t%@l;4KQGk> zKs``W^AF`?l_G)<>f%*dES=(`1kJzkO3%>qc=ZB&L)+$V)o}r{W3?9|c(&j40^ah+ z8vd>uMW$Y3rU6ikhz=rqRX0Dz0=5D5&~yKADgXe!;$r}xtl8KZL1*29cL7UohhBx+~wM0?Q95orB$f}&E)K1`Nw3J_=z?x8WjhezC ziJrXp&=V+{i7%I=2q6vSOg-CpxZwf0qWOL=JM z7$#)UzTD&VQ~u=yXYR2SSYW5Q>&R-pqXQCzoYkmaUZ6&GAZKYYp6Z(RzdY6V#anS^ zw2>qlI}XRjx#?(?rKXpF=Pq+lQ>1FHct+m{cRA&J)RWSf9P?w2>LZ0ftq zrZNmp2PvsEJLzBsqxIk6%zh92nxMKYo4;7gM>kI_XeaBjopy`f=xt2{skzj^>l0&= zOGv}wj;*dxMFw~xJ?9PyA6lCin}>wyR4=uTrz){=n~Z!>nqeQ1BNx?-nJwC#e12ZJ!rZ*v>{C;Pr{E<^dX-%SW6H??Z@yWPO=|cj2vruT`(sNhml2(I-$;2&}Itd zPrJ;kVzq__jk0cCQ(+9I4!3(Y_ra0($6Ppe?lXmV*U^I4Vc6`!q$hi$30DT{&T*j+ zAdX)*4(@R}<19tI>e7F*UzUeuVx+)}`?Wz`ME5kpb|iwkafbqku-#B-n?IpR*L*0j z+lo@`&A&4!TPOOqVAe<}nxXr?0xMaO1Lns*A+X4=^HS#fE`a}AAYK0JD{>%ed`oM(!cF~s0b5$|cp-QLII>sCxFA`LcSRq^M zZ}#;<;K~Aw;ylM;xnqjFc<1=OyQnU+LGSagJAem0u|nj|S!b}iqn8)*%w2Kq<(Egm z9ni4YzDnHlgH3jTljMWB5B0Pin{%|e4Nqok=SXlo;S4ThMDSjq=Xpn* zt#%Q1r;salw9I&mn0`ae@1x<_^(#7hRs1aZ(=F@pe^f+dj{MS4@6Xc?^cwK*B?-cM z7O^QYSBaHS9l((L+Gjq8(j>v*=E*b}!LD}V%8tRfvd>y|&I?_z)%)!{=$X2t4)Js5 zzP(laq4hAT-}t*bx(8s}u?k>i4JR5La=cGH@t5>TM4RZH(C_NwLY+?i*qNN>i&4W~ zSU@EEe`MdO)bEQ_-)mwO(nLtzy>=;@7ilDv9JE==1)4>)D@7Duf;vT|Tb$8<&aLtC zc@l?8sU9h-Q8yg`B*RCBtd9z(X5&#F?|$^h)kc8n2=BNF0eeiZ^Eiyo%-fYMy+eMs zYSp*^uN6>O3YVL2NMpoK{zT^bWyff0qqi}MhS_ST#~sRA*n1&S`LN}Zk8~y-7?1-J z52JDj`rVSikve!c% zP!+2MwQRe#+!upSWR1jmab$g2vqxSpG|3f$(P21qoSaAZW{KmGwzn{4LVztp&t#=` zZ$hslnn8OeG-0o3T4QvahcuReGEU6p73J!tXOOEM*KUW$jdm_dKzej9pGuFX_gHrG z6MW|Fv}wd2+i7XFtta{!ZQkM&4}_(F(adflk5VUzXu`LfzTN0h_4Mz#?!Vs?{oT8# zdB7%IZOk)-ftU)J?ESpEq=bwzH7W4F(ZAQNiRC9GH*O2V9Y3=zsl_KE{nm(ud8)pV zeTj^dso%W-&V!CC@mbwQ13z)8Sn}iZ>poopoJ;_Jk;kIXJBC1V9DFqDQC=jNJC{d( z2%F4DYT_!8w1_EW+VFLzzyZJXzYb(rbV;h7v0i{atB| z0DiQ2-DMz&rgi;J%z&pm{5oS%+-JUKhLyAJbmELF*?4(DY#S#ytSf zE`rr5jL*0KF1{98O-Hm?>Q$xToj>g)3#6IvGv?S9%+6;1(7A;mx60p{tsfVjhVKFB zJYEKu(~e}~g)cjyUsyOh_V2`y>OIby4Ir4R2CRTIddv5=uOw7U@&Y$)4Jo#MnbYqO z{9#R*(c+_TVFbXFySb)Jcfym)_gA1RUb?Qd^3Ts=IvkpANHNq<4Qjrq*j^_~^`I-8 zaytdo?}rrv;N%pkYH3CDB92(|zPvV!PF_F3Cg`}TDz*Y-)S@J%p&8@c)(VV)s6K zI(4eqCOCYgdQ!+O`R=aEyiBxy%jqOU7>}1v)?`;o3#I&77{{MiBN4PNtf2e7+o00b z?32pAhi^# z?QqP0+2MdBiKvud#xY0!?jHHQd$;we=fYEF_zDxOR-;2w=r*e#4WHG40plOw+I!N6 zY6JapdsE%=OPkc?$$8$;0NPeBN2lC5j}THv9hr#$WAa|MIMQWYsh+DHsK91KoOTnU zXTxFkyGh>%Qc^nQ5-Eohf5LS2=a)nt`*v?UJc~TEKA_J+T{BNZUBCSm>MFfWr~|K> zM9`UYf*h{d+?{A=7Mn1)6F4C9?&>QZc^FM(_208xVPPj(uHtI3A5U^ucP&_F9s;bl ztrg!0tTWb|5r*}~4Y1xu>rVcfFuAK#@k^EM0PD@*pkeQ1v;xMc?C4lwD<@THP z#@-?(!VJX2UhGNYu0M;1T|JJ6RRQ8*9eaPr!;TjhJ&sOH)e=8HRNiW{J*5J~ud*OQFfqR5hB3e|$8JyMeussf`yJQ!kT~NqGQb~p;U-ktRIG)oc!U_Z zv$wLttmwWU){#J#;1U$FSx9fr%0a-x)m?5<&e@P&zS3X#vt?5rVVC88z0=S|Zlf|> zRjGRlvf2Cu6NIXRO*QzlcYag8Gf%mFa7f;V_DNcI{ly(l#MjuN+L+N=kl#-w3>8jx z6`>K;itJ+Tvou}<)rag1lrT5|FgS(cwx7o^xN@42OFd;~9@x@zCA znnR_R>g2|D$}@dvTXPRcf56glY`GG~_!KfSro#OzY=UN0U+o{rWB`*zwz7O~h_|41 zR9(d`OrS8I@Q3>IkMgsE6`n_1aLNN~eHdZgpsLYNP8^cU(tGeoi9#7iaQu~) zLAD_L%9#s8ZOr;9Z$u(X0)Miq{fdm|=0z&ghwM=Ev2^AWO3}@{=S7xlT!mG_NU8uH zxlnSX{rDPeqMDC4hQJlYpB%ZXZt(NbFV)9w*#^g+vPvD?KaEw znjS}+@T+A+ZZsu$^$rvgRrbBIRUagFO6YvM}VR z8g^q*DVTL$^zOBn7JiVqIT^wFF}&|VH_=;9>F0hqu4=YpoZ}}rx=C)x;hjBVN4O)g zRxuPOG-P6&+WesuiyGPj1tqKRex%|=%?DvalQ%`?-dXh zff=IMsWNpbHYE&*;a@_K8kPk>vDde_21lkQ8xi5;3%cq9laKcd?N^H2nZCIy zBknxv%8X~mUM+Dc5)6zA^`CZ^w9>AdCu@Ht$5t*F_=7i~fFdxq>f^Su51HOa%Dkb- zaC;C9Up$D4OtzuDu#vp)yYcnaKRIZk7RDBgfzk1cEp63j@nS`qpG zpqItH3dFEN2q8k@vwYXY;k?|vf4GIHry$%)Obn|Q^6CY8;@1lxjl#aM$476b4vz-z z95Y$;uL?T^iZSL-s=v2y6(g**i{pJjgT-HNTjv@#WNmq`Zf=I)iYy=hg;P7&y($!y zSIE=^9%k1=EPR1i-e^){Ac4LvahBjp2;Vr?@5hxGT zH-2`#M$buZFN&!uf`p5iBA*8=9&b%CY3Jv&dNhUCe!4LM~4V~ z2>P``dME6zc7qj<-O=N=HFUk&id^m{yt|EeLdNXGUA1pN9{RmkycwM+=3V8`Av{yv z2Ziu|-X{igM{gv*;h_6)bB3Q1FgsQwW>XpDA=T&{@TK;J-mJyV#$zTI-Lr$SG7S*# z0;BfV5H-pQ*~HzK*u5m3_n)hj=d8#`}}y*!|dVjO%Kv2E-5C%Z?m?k?LoQb zBbc8hm*m%jr$oA4M+@VeqSEB8G zp*M)x&28r7m_B^^t16zf&Dwtcseg_@$=G#v>w(nwcTF)lMfZq}KTY1@IBUdL7O^Z?h8I9#nU{3*r1HTrsoVava{|bX`tv)9PM)R%Zr#F^2-D4=+^F;_8TdH%ggD{)JiU@+ zRAO=-IM)U>@#(dA_dOIJqaG=ud#MQo`1*~@bITKv6JaY}519r*qm-K7PkTNOu&0*C z_G39OeSa%hyN&HIKLob+gNaSXY2Vt!@wL`kyE4+K;3Gw+g0Cd4n=fbubw41f${I{R z{RU2@!fJBn^sAn^+_|BqiFna2l3M~2b7>TB6|vW8C2wKL)wV1AIAgnn-4|!^wI`7s zv&-HZp$ITX9vvD}wfpg!V-t*hmejr=`VoKT@NgR&CzA(Xe7+5TUFjGe9rXtut-HqS z#$1aajPQdD8;ieYK^;ka+XbFaiFUu^YQ~)g(fi(M>>XzJapfmZ^7e*%4E5)?#!y2B zqccS?%o&mdrF|s%fgs;CIloecSjvSQP@_WVkmpG`xD55gxz^`y+E;%|L13O9jd^;~ z-%tPSiMGk;_BfKEMjH3QeC;*a+MO?wUU!KQOnQ`!N;~u*gn7@D!E#HI_jbtir8gUJ zQde`cn-9%?EGR~Upyiti^ecAnNm%H2BPWwGo9TDGV29SVAqgA;V?^IuB!_N#v2i{B zd8=gJM(ahEVha9mtbwYkEgb!zEHN4XvG66kZ}Z{_;GvQ6rgb{+ zmT@}L<$X^UwpENg>&e1NQn#_@94qdJdQSzrQFC|sT3_flR_{=eY9kUnX z`ns8%8`z7{x3DJmKHG~?Io^xO0rp}PPT=sEy_lBa*KN;%y_m)kf>xrly_gBiUd$S1 zFUD;2_g;(!mvT$7eJPxNYIKLVfC5Mi9dI$KF&m4W3?5yLy2Q#oWG7+w*`8`#D`I?J z3?im~yn6%VmawNX5nax5RqmW#g4453*L^a2ZGkz~TLOS*`&B2AuE|`z{Q8jDX`eW> z%6km}Z#`rYXrzJAFdGxZyK2cu$;skhja{Vaw|gs;G(c(aniZ2!E!B&S_uG!F3V7s} z%#>waW>K1+TT;#|Akv%3$>cx0AJIn^Q%4LH?t-qTKfGObwPQe{u( zCMzq2&kNlf5t|7g5e*xtQJk1KZ_c9D6@Ck=qZzpY_>Ww;1OX&LUrv91|NH)aVP=xY zVqrndD=YhrMapVu@r{#odfA{WRvK4gmhPn|LSEqwU?hbwmrmqC<9_W}VkV2Ss&avl zCVuUaP0_YLZc*$n8V?Ae+fi_G#V}K+K$EM5ha|ktoS={FJ{?1;SD_chyT|_WyJjnv zOP;{uOU;F|#g{nJ)%qoiy7@1o$X7{j7eeaz4f2P|C`Q~bZp7ETqVWiU77I>_R-qwV zTx&q^>AX8Y`GAd`{>mw3Dw#Y9xWu=w5x(exSH9hGjg68~44c1LRT{8{Wyu?0(Bt5` z$u_X_b#@iFDN^T(r_S4BvEv_;g=%h!n8$@D(|^|%7Et^m2%v@BY~0>}5BCp49&;}& zRTqu_+b#c%Ov6WKTpb-L-}aeuTK4F9&gNruZ?Pod1ol2cafv9`+(c_7``zOr#s0ZB z$K-Rb@*Y|>d!Epo+UK!xOIHBNI!zKS?=^3;YKM5~oMU(#UNHFT^p=r%j`4smpAl2N zwBqk(oBgg{=VS}i)xi5C<&Wg;Y6g`KkcHQl2RxW{Tbd}Z9E7{>4qoVNzYs~{w(;UT z;Mc{xNZjI~t}9+}-*dZapiQRvij(N9O?K|!C~)nQAm|frWNV^0P`Ui$kiRR}6fA#0 z$Y}7VR={Ie&p6<{3Qvp!U;0x=bcNJZRYloj8FY_Jv8L$N&yKcD~x$@ zzbmA!X)@F~ZYNzHzCF(2niNknQ}qJAT^LFYG)HnG9#$s@4fd~ivF9FHNfoCSrs??8 zSQyl+3G4y#e51>0u$;Ytw0J@;z0Be3j}`u$pLF27tmC|GZEsb6m0wQ4Ks!D|MmG6n z<>KgM>F++1WT13>eHJFPKpar(Tk!I)WxyI#nh~h}bJ6VjR9|_C%qq%2% zqxK35ZYDgjq&=K`DhX#Q$6z7WlO6jkc>66LubZVyjHq?p`14{s#NVM6_*4H#Ew~5N z4u*t&n^ESqZI3&O^L=Zf)b7b8PU}@`YH=}6qGl9g)j;uK$V|nTL8wtSI3KsSwEncW z-fGP(RIT?&OOUAVC0oYSOMHX#U`o$Hx@!)wA*s83&k;A1oviw(M9>R-+~z9z)8@iD zc(K(bjVg^@YY3o5zu4T04D%4*(In&UYqh5-PhOsgH}mfC*lySuMO<=tfQCEns0{Ib zk1qATDKm)$>_aMZ**T8O4y~gF}u(EWMjeo z7cRwQvu0Je%j)jo#HUrmQZZSL>g-|d25ei0)3r(4s4AW-WToK(>*InkCt(5fLv zW=Z=6u@;)siy)FUCkJ6hNz@SPL=_Dxeb++s4>LZGM5G_GU9%W*z zG9j(znd@=px6DPHVA|2Ot@1gf`%vs)w~bcdQRSxnUgj`s8Nq z>VjW_?=^j|RWKgvyYVPK0~qbunckelHnATLN?6>S#Y$iC{gjN|zSNtA9B&MIFLZr} z3bE?*GtOw14!1}pFNqw2+gKwz}$?3 zjg7jxopb)&jJrCGvy*j)e$uaGORaXzA@uH!WFs|yzgF(0qDWsHPLBRqk+l=SQaXh^ zZ;B@{KyDuUZ#VrnAL|v?N<$SfwX5R^P`f16j&1^la)dfy70cXCW9bnwXK4Xfgm5fR z*5ctQ6j?(hJTJgZbw0Lw`=qESOL~cc^yI50WOt8u_%nX*@V^}Lwk`dH6WOXIW@M3X zh^fKHmxd$8O$6ZP!zs_&=af}eV9k$hULsW9-^D(5%TK6WU824EfwMF$Rs;Z6V>DOk zH{^LKyomuO*KM{oD`UMu&EK{0>;6`Ke>F?6I;gd8HdZB?vD;G}rV#L_pmgPDj-j$D zjtffjCol5o!eFG)zci5BoP?sHvjQNq+t^0zxxE;pqyG@4Pj^&Co{%P|z?W?t-`oP@ z60X8qDShoxqT5WSwx<0=+W>YoSNc>OO;l1&K0yQ@4mBeA@N!pR<)+JsUAt*1#K_MP zipd&8fVxI;f8oVh#&<;1&!-*g?74W0u{p#6eid}$OHB<-gZSP!OMWGG`K1;8@N8J}7N9$)+sHOEXk|2_EougyM`*RGJ=q)I zWo(xQvT(2su(K6;5~qJ||7Rfr!vWVW%S9rO;w3i0X+RbZ*jX_taOUa0OTqV@$ZA-V zd(wTK4eQz+kMoIbXtzWZrw4u!&Ge*?{O%>E2i8jN(2mVZoM}R}KqO8RDCX#JzxTr? zvY}3YeNx-IBRRAAjZo|Vse%&tMZGHA4k##EQ9wb7d1<|vq3@2O_}+^O6f!a$vG^ea zwG*EDqPIl_+pM~Es!E)=J;-I_M7^1pDI(%Rxq*}5l+)cy2slPYtd8imC;>8JVeBdm z_L+?6#>fb3jEtaw{+1D(^{7^1#j?wBCr3Zh+r_t+J**&AA$7vW1IBhG`KHEp>@BpS zCu0yVp8qfgQR@GnjzL%r?DIb%Ty~z;#5-+|w~b0zU=pKHhnG#QE?Ryd=LDPa0=nT6 zZEZ|nP>|*861M8#?oi{N3E2-wch0=Qp>Y0$mk6|(O)f}rCeE_g0tlJ09Lv;837$)x zpL@A`FS>I*>6a~4QBGV_{+z$F4}(`>J-%2@N^199YP4E@L@p@xij0#)yeH1G`TTQs zkSj}>s}5eKd?Hs2&P;=LqyX<>{FhuLktM;L1KE0)IRr+yJWs0z1Thf0KtJJU@(=x5 zxAtgoib$VVQbchN=*Ung>k-1a?s`eif)gy-KAOmj%NJ>=X>K#;vq#ssP z?QIcg)%czsI09}gSzf)ZK%Q25({hm2?R)!JCd1rYdb)et=byXo>-!qc?KjUg!U>1~ zaIO7KDVFJ)Xx8#0-3rE((%Wgd!2T+rQEV}v&xqo^7+oQ(>KVwvJZs4Ok3^FfUIF^Y=W@)w|}NSqy*dgj`(&Bg*D?bFNP z|5{aSk{Lc7w{H?Crq~<2WZx8dd9D2isWQb1loiEyc9`x|d{>uh99=q4zmA0p1Xk7S zHahe(YbCo9&Cf{ngfsc-XWNrdThB6^&+Q`OcuWo%VNWoEsM1gH=i!%ZKZ>Q0vaWxV zLsMa%>Ck?xN=)feasoDirDM@mK*eqZYYydD?!q}@dJ(Z8SSSb%hV<9_ zK?YZO>2HQ}B(fYwSj`*5{pBD}IP)T2pmv(==#Gw#Oq;pjNKRasG+_?B;L@!MzRL^-~=_kUDQLVcV`yr?2n z5UB0sU;y2c$E{P;yK<45rezzsOz=w9mOP{jkT$u;L+*!vhTM%%`>mvP=FV=YG23fv z*v9NjOq*-aE(6o#n%7IiG`Va(&i&*7ibG)07eOF7fVM|!x%kAIchCsT$Vb;RVwRk$ z0$=^P&JchjDe{7sMCa;9cIF8Q(jj$q=&dD(hXoP9WU>adLKqE}L z`FA5sZ6+Q`#-X%Jck@i?I63ns$2&p|Fd!NBs*zQ0V>|o*`-HW|zX=TawXnye|$kz>^us zsLN1;89DW(*1Qh>+OE%v=VaM_&_RaY=fg%^gMW9ok|aWkPO{d-vMQK(Bv`DD1iQ0I zvO*7B4>;=hr=05JLA{>3p3vu={X~x#5op@B;212BkfsGn4=h7p=d-5%ZFv9vMDfL* z=2EZTvYmBaKp326uEA)iU{?64tAnFs0|%EgbDS&wodR4wd)&E9|Bretv; zHq=5zAM4D<`5d8=j+lGz)GM51B;$4a!EpqATlS#n0-;;o_?R}R_-K07Fl?I%f z?ZLFtE%wo5#w9{A@3_UYrE(U$9vEn)>`d-$`)5$sRDV+SB#-|2A5Yz!N@EG)xA}Uz z%uc2&Z~`BDngE!U6~{o7<%wLOIinUcG=B0jT65^i)XYP1>piIIGirBPjhL~5z!ZS# zgPQpL?VESuxMk=TkPrvW$YA>SC3vBaRTuZakcvdh53)=1Y?tSO=23vLa>;4)=re~( zgx%`A7=5B~=D&Z~7i%N?vfYoRx>&= z&1^E_4m-CeIGKv5Ebi{#TZxmMD8!&%^**1&XzT83?av@p^JgV`C3xKgH|&pO6gF|b z!e}2IoW_vuik#f4U!fd;8Q{yI`P;y3UAfwy5!IDN2{)onCsO4aj43$w|>yZlw(UqSU{esVl=F`=x% ziI&!Qf0=x&o4rsw!`?^R;0A6qDzrh{*jp(XBv!J|_v$SuCNqO;0_>H`mRB!pVPeH= z(MJM0+#aRhgd4MnFM4pM4Gw8@%k7YP*A2cK798n6q$+3cSBmecwfgDMu;NtoEQqX` zD4tS(_~*FYa2lt!DWVxa@~9kkJUme=DB#w-4rQ59tEXU3Rs)T?&AY#cJV}KXPp^+& zOQ^`7Do`JCqaI{yG<2Y|R&6qJM;*wEP3CVJL`M_d_`dmV#eVG7fyo3r%Srq$qR~mm z&*lUgR-<_W4g0IiXcIS{Xq7SMe`pm%x1Bu~w*mXfz$H8wby8;p7XDdhbeOn}?b*3b z1W?QH8}P{-uYnf8l(5kTe#4oX^74@7=78|-@MEJ^$Q>bc z3DMEcGj!^ixMlK~N|AKLBFM@BF%w`DamhSEmLQt~ru4sE5SrpDIuls^Ti`R|Xu+8?IF!OS^ zY`N{IfBJm~$Q-qj~7M|B#DnD$$w@d3Ru7TWyn-y2rk zA7j%(K18~%U;F!CrF#|ZIje!|i~V%a*9^7=u5ZB3RvpkCNEf?T;psgZ9``mJkF3oH z4mUB%;4V?SJJB)U8JXuHI3i%g|K3Y`)uH&H^O+H6?pL)zkEns1$=d|>_U>-HyHzWB zuv>KklH{i&S%DpGG2_iadL3a_{+-E4qZaZ%onMrt>VlTC0=pz}@VZ9GfUe?288&n6 zMyqI&_1Q-+YPdV`(posjzK%c+qesgd@M?B@7))cSgIZ7(Hv&$rOK-H8IH%fGK0AS; zNhSWE_`FHW=OnC7Hjg6EON1-2HulmWw6n^{>etlq+@w4G(qm z<;^K5k->aAJMhQd4g7I`hX^RXa5vwlv=ek@8BA&4F5C6Y4$*KC^AZtc+ima?pM;|y zfa@H0w3!qRs72*c2lm$}4#v4kbdHM95Fa&z2d!BNeORnZ>vd3+!7qGcC*ud*$cgtH z;u6PRB=8VV6@^=cO#V<#p{{3rOZztGnn-r=1veVT5=wMDtNs$Sv(9kgWS~Og`Dyf420y9t0wAO%a6f`fClDDOmbM}9Yh15n5mx7-;l)p+$5buvg z+?cm8jxULtw*cO!7u1*CxWw7!C75M-<&vU>1+5r&k?RKaO?3HMJK1MdD%tra_P_rX zWU0&;1*vvs13 zH^V5{?2h;k12hw}k}mS_a66pR1)f`dKL!pLC6rKC8Tsy(xjccZ5x5?R)@ zv2spOUU&p>E$aC- zBIUSZ8rdxv3F+dcug4GN1sZ7~wA|qJGSV9#QwGne=+OOoitvgXWL41-J%j$0(~cbo z+gOsqed-+bLVUX$O)hg0WYit4p;0<$IQl3VjS@QAoAEx}KpixUt)UAV&^1D!WT8E; zquB#w>KY7e1tJjec5**j-Z>oEMwY`Yw5O0aZj(Wb7cXJyN2$eEcdKg(JDjBS*4DL;ca- zlGyhw5BpZoWP4PON27b5nI$^R`9<<+7d1lpen`4ADB?VjamY4+Q{je|r+vc}eV6)t z!i6dv_Zc1)^C+cffd3o^&m~$X*#wbZkqC+qK`EO^Zp#pV7Aq(jRv4ETut{wy{V{1rk>ej zpE>$8{AHiesy+M~^$PXU%z7%lifjL-%igc~Ikt1AGci`)L>(#vx8qTgyTHY{f|TNw z*e?@@(^d}@%^77|O44u}-ARJ2>yAI4@|EDb=XedtV5Ftr5qNRu*4^EMHxIrlqbqyz z*~3aBvqGCgzmCtzbk0l%#>cdtOAFSiMrqMc%F~S=M6Tjg5?XwAE-?lZ>z=;#bj({< zjd4qAevfpxO>p|w*~SPJ_uZEn92bXoc7e+)p)0%pTt49+mrt&t9o?X=-gd)nxk%Tt z8UcZGN|Y(M5sOV&R50-dG)7M~d+Z0&iCCT+WM9avKENs7jyvjQ9ku_m$FOKq6JUbO z|0U#WB3r0PkhArcuGqROy@ZD1kjbTD;qv=eS8!EruE)L80~Q3ITJ8P%zgTEz!?nY1=k*;@7pkBV$bAR`9yx+eb z+nHfz?{lwpp1-yB`cERCiaqJ-W|H%ajUrhy(D>6S@E^7`-w;VL^f-pM3KXBf{UkVm zMQ+##Zm5%G_EPYz$QnzBgD0q3&E>`fjt4fM%MH5HD2gHRINnZBd;zx^_~_|hM>{78 z5e~T6g)lz#!6BSTlL%~4^OGcbwoc?=y1kUiOxDD06$~#)(){A=OtRSi@+a9qA@_Do zLexTm;d9cD=v6q63*j9Vvcp&dR+;3cmKKADt6-lw{OOR~4k$TU_>=tenH*+~JOjUx z8A`{1HWz zmRG0smC4C)&u>1lEJ96hz zfLw`m6WG-@;1`}J)g!x5L9UmC2hEi;Su)M9Hrsjhj9}+++i7AwaU8 z(1il}>bA|*Oo&;{DSTPh7w!?M^V4GiHQ#km-a6qN*nL}Mw-S7FkPe(`RY)my)lsxJ zD&bWI7R2QgxLUrjNDn59qM^7pBXTsWp66iqp&i;6i<9r}w)EY{E)W=aIi}%t;E+1) zKq1IhPhqa9>v?2K_hYe$B_Lamd7o@FZ|!@4pkI#r&%7P98)`B%f$W1>Va(wuGmnR< zvjxgyMwc`{rNt%T&zOkU%g_aeSj$)QRtdzrP|KFcloqAp4F69Y{6^0@h($ z+PglTd#`D|it!MK9!GN)>vb>squWF-s8c&{&~ew+7FCDGtNJ0uDPr|G;Im!bW@#{Qi;z!Ln9|4MH(e!m*~bpCqpC`ow8qo0$4NY*E|+HS#h@Mb35U84d7xL_6fAPqZ3As6?qfh+BjoR*iV z`HjtpzN1o`kuDd5i3u%g%X_;W2Q7inliJ(woO8`erF@BRaN{Luq2`g+<0*ROt_cYc znK6r`jzG0+#pz(a6C3su)XXr-9F$k%G|?Sto*ZVY(VHrBxR+CuB?2ZCW^{_=0pw!e z-LIC0(z@CRxrD-@FJG@P=dEmXS$~Qb$a|DM1uFM1lCi)x%a9>8wyt70{@R3wS!Q!2 z8zG6D{`$616n{&Bn{vz2T0it0+s(LZymP3__7g0h^S|WN(PmLL+!+0Fl)ti7*kqbg zc5PsVB5(zANpDHt*BRR!UQbisa-n{UDM>2om0z2Zx=xooqHH;Hk4NF@`xlDcAb!NH z+`AiJk255>cd}A=AuoS){qjRrHW5b>psd#Z#XP63O$Ejw5acU~P1ri5iJ6Ht8E_po z&;0!c-M|~zFGXB>Y^l^800Nzv8GMkP`n4oz9&bwV$ym>xMC6oPW}zT0+7gqU7y0!K zrg2{P?v<{Ul#&)nmL8uhhkyx&beap50D4D&;Y43HKIgI2Zr;Xj6vYUNf`Gr5l;u_} zx})KffN9ysJvR7P_Z~a=CDkcrVev1{whN*+iBJHKdB#A=!^SIJpzsK0Tn26m1e}uThdmkcE>h=m91o7oLQ#!YHNQZPRLt%X*3~bG9Z$6RJ?y3kpkLBaq(`>f zP`Z~$$~aHz>hpL&Lv#Po&=cf?@w1JcOF>8Ms{;46(Zn2)AIL}J1(gqPCL0TjSJ7#c zjAQmb*;LkLy;U~g)FGU?^yOm!q8%$*@7MZZ1dI^)JCn9e!!4DF`_}aLRN{aONR^<4 z3O|TSEt%q@M7p`Os&{5_+ie5uv>5qVc)X*S&ga{Z)*fy+--~ITDR~MmOK)SQyeO?3aEH< zf@bDmxY}-s;o!KOQHzc4;6L?YdNIE+v&ZZUKS+pxH{O|WW+su zXpZH3JDw!dI(6=*U^?xwBQNk{@8AXcN_M2Z!Xi8|zWLsv9UI=p&$Tlw>ZEqNLWo0E zG)Ie5Xvuz1)u{bT`#2FRh3r$an*8#k&_!^O{UyIu_zT1@k8s*x|R>=8HBB=bV$ ztj4(8hZA&tJe5<@|L;DY?_k!FQ$0{?1V- ztZ63M+_|@(LF}VgW+!6p=h}0Xcn>Js8rNc zmduv}t5)AG{IrUNe)QjJenyJ>V_u9e?r_bVMss*%EgC#-9;j~7^!Y37w;#g z8u8aZzQwFg2#lU*xKs{YMdEYJkRo^aSRdr6V(2ftsfz zdnf@vZmy3Wjn8v8?oeFbbKeSuO73@yO0JaLD+H2qxzZ-zTAT{jqc}hz?=5@fC=i*qp#jHbO z)~UxRD||*0w`_welWYQS=}-6#cOwpO_8qneU&smV%I-)a`uL_kx<J{c=`0U1WSQ^iH)$TUv)_8gbe`P(>m_Cdk@vvo4z<}C9nN#=)PXG?Z zo>$Cd*Dc^?-Z)b-h|14zTaMeF@7?LV<6K7O+OvIOeMZUwJR%(vn%C?Kj{ zbuh09OWeBn!wy5h0bcki`v-<8c{N6p#2w`H74|AA2EQ$&y+L{*&@vfwjb zQ-?h)*TeGrTaqycPSW9^b?%QY0{ZEWQg-ok9;Nu(Myrntbo@4NyvTpHPko%vr(?@nMQqEc6cvVZq@%Br`J`hnJ!9>Wfr z_f~}2N!}9dR_}$EwR4dx9YBVqKXcB1Ejg}NeVHda@kJUbds}PkDhb9;HTM+Bp_Nge znw@@AV^jP$RlYgsJEWLbHS+Qu)h5?(JWLL<$W4%{)38C;y39Y8g`T3`cxIck)6%aY zZ}Lmm>b8p}zT5RZoejtBKLOXPw#w;(*Y)ZWr;~<$Xh=TkwNJrwHpLkt-ze>$mDG(W zCRucUtpBq*>BBE!QXllfgo0iU6B@1mCH~`%PbI@G=r+6>47cSg`Ah;5a1JOT&Gd|A zjQViel(E(;gFFz{T_xXK!*=<5(>T}{@9SQGir;A+geF`*gY^b9W*d{`r?EFq0a51r z^$kHpd6hxUtgrky2E42UowAv1B`m|yBX25Qgs<6joSazg$m zy}Uv)5)+y}L|FAZ)BZ#YC^_SQm7KSDy>0k&{s$@kx7v5i#X8(rhZ6C9O$(;LBP75O z05?#vqW&Kq@NdNOk_@@6C|z3<1&Kgmy|-MmY^~;3@;b@!2IGVjb{Wcu2*jHx|J$1w zC{L*%(tnvIfI4!{zh-t5#ns|+SeE&sCV}Raw&=N2t9|9BOjmopr z|6jzI`MuO|@~I#{IjPr`QonP9$t-4c^gD+BDuW8#oHtzIS!T*zOuD%jd}Z-M@y>TX z3Ew4+;C;;>UlmG8^@;_VN$=`fHis+UybK0pbE3Aum+M+KwR?2OX4a;jVQX`CIZPLA z>6y>ru{Vs7!Olj3!nD5o1&(ODz=$3p^xh9F(9p4v^7)`q7{wO?aw#gnFn4qSDpyD| zH_?W3P?deW19!==StQ~Jxv0K~6JR3Y|AxlaK6RmDehnqGu;6SW35J`_g@F8Lwa-P@8Pkt?kIMUd=~#&bl`^9|7{)> zfpYfjsrZxXD$*g^Rk~DJz1iuhnKtqstq=@gVKwoNC*@JVQ+S9saJoN?iQ%j$zLaUn z!sSZxBsp%BlATL3H1l_5{A7T83*k>0w#7pf?+=c{EwV@ZK>Z~zx-Yy&=S36|EBhXY zILvX7G7SDXz0dBh^HLoi9#R-*0tO2C-rI{uJaBI&%n_k2lg>}9`Q&(AuGASfUzwKL zFbYIZ_NDMoXW=GE({qN^r$lt&8zK0E29<60iwnn;mm7c?xy zIPgF+mJAo(F`T#v>^I)*C;-N|ymO9XS6)gKNsn9{?*|niS|A)ZJ6Hl>G(Xf zc7I!C$GB5#^o_+UcxnNJ#sI_dzV7L_(Sba!e)77bk=L#F%whh%==)oFz9XZze)ZiR zc-EV`8`87?dTKRzSI9v=ZZ$fhxEqoiR$FmGR5cCrZHFI# zp_Na4U1+)p*^zyCDv6OVat8-B)VqjIiO+DFb%u8Rn<>d}MEI!#yYAskjZ`Q5w%UYwUxaQV-_$iF$lU89tK zJtDkr{u=m(TIFVQhfoF4$H&So4p^TEKY#PbH{?~FKjYjkCOYqU1u{Hvj2AUxF)hDK z{*<4|?Ed6)$$d$F(WU}&O$>p83Zd4V;yP(;bHvkZVTX1ulKy;-d^Dg!xN(ZWIMloo5hpY(X-uMGo!Fv#%&J;WKZG z#Eu``8UZ0V1!f%kBf2Ub{nWoDKl{*!RoLpdVt=hgSLU_Fj~`-Xm|enslm-FZK|NVeIvnR7Y5Y>}UTdfG%XXd6R(~=qfT;DZT zk(aL)1I%*vi-)i33bEaW{8r)C-p1pUuedlOcrRpu(@l6%y&TKMMK__VW*xLJpH!dl zloDb(k+{~zoo}x#Bs_u~xB1l|RB&Mt!^&?t+rh^hYkTOeFXX;#z4F!kM}3Na3HkvS z*x8Tq=Q#BV2>1{e9^4Oq8Co$N!Uc%~Y9eFmKks;9HZhLOgU>@f%&~8XWOE~2Q&P<+ zOV59hXk_WP5wIgx-TA_g-QmOHT1~gWx%LG~WO-i!eBCwjL_iJRj0__6jhS@|ihj0w zjJ_efXiic2Sob&yWs*~~uec^odO%>$kxD=}v)M$vxNb4=(ZoOpF#%Pcb$7UKfp%Mw z#3A=Zg!I?m;#oUs*4${E%vGFHX;3FMf42+u5q-nxkLpw68#OPmKHQ1>^vT3nha`bq zzHG1H>_^kt>WasU8xQFyFtew~j9C?mxWhlLrKD7SdLR6unJT1c+~a4V^c4=@bp9rj zbb_?9TtaWgbE4Czmv~JkY_D^+N!4J#FkaXa%I8*GNhAG&x;$pf`ymzv`vz`^&2M|e zcGyI3DR1$L-cn)g&)EI`e!#jadb`=3FRyVro`NIBM|bG~+1_oDB$fpf?EC^R=*b|K z!}&NI3)Fz}QpVD80f{<+dU*;M{R#?gE^q=sUT621w5jjk)~z2+?^DzE zB{*`$hFIrDzGtW+&77@X8yC$pbV|nMGbOUnly(h*H=~j!QOE49r+M|nG@iB5bA;Z^ zuQxZ~L(ZdBQijqCB(hB2xw1??$90(#^zQf%lG6| zH`TMv#A5MNh?rVO)cLxx*nV@Gmi{75Qk_1;6M%K~Z=)+LrQrJPp)KxtTbQ~I^{hsHqen_^EKTAO|=E4j8zh|F5 z8ZcEf5Tb6h6MYgsY8q`lJ}MmH`2DU5^S}cjEgP+)OxO3>4I<{>30Rj-2Kk=RI!0kS zyzt)ZcHP#z%d9`3!<5B?%C_g)PeNhxJfY$3Is3B*N4atSpjJMRmV1kXLo!NO_S&V9 zfw+fPnLO?e=E!II`QU?hRQ<-lKM9U;>}?CHHkw>2yzg37Y;(QU8#vHaM>|KFJHWUs zoh!~5ouQjE_;tR~SpFT*;rJ(y2skQnYr%1-F-3{*IloE&1f_Zz?_6qLuafA71Dn-*f!*QIJm&>XC*Y zTlBT_T{#4yaTnh}==Lf~h#b#IZqp%!)CjTx`Q}%K-?>S&)+3_M#vViaI>DtK=3ue! zAg7LW#RTwwve6b}$jE*M@GwZQw{j$_y%=;8K-Rh?uj}ngl*;Kbb+RAys4gzrWH0Ct z^ohNlk1FrZ{J~44yjsz9h~Y4FSZ>unEIe3Iau3C%eJ$C2yrUj5>qnXts_gkgJeYIm zTjpt87Sg$@n32KyfLbs`2>ktf9)_MM9;O-AD#1~xPR|mzN0NyT`u0d>f(uT zeN&g%*U$9qfMVS<=OYc~@@>qlEv%WuoYr)+6b1Fg!9ZG4bfK$Row>hB9Nf zv2CqbUb^la>YE8nD>#BY1-!Bk9lpc7;aMPIg;8^IBsIn{>b*MT{B+WJ@G-W~V{mRD zm|HYCX`1S)iTPl~!If8&NL#%WCJ#NP{?UY7m_7?R*x~wMMDqeoxxfe{8w-K0$9Z>fq zRy=QNIM#o}dgMsD0|&i_3cFZdIXHv~E+wmdx>0CZI;R=La~bGW&H*>+)J0~ac~Rl< zV};*1}J$}VeL|ZxGaZ_eAN|4!%bu2#t=4bjOb^g_5F>bASf#KS!h>d~(4Vqz}WqRwPBp^5cw+%!&~^*cY6jb>s3 ze$;FYd1Kb!1)M{`ec5n8j^KUWzHJ?*Bs-FoJo{^ve-od0N~`XrSlKsv7_kfoCJB6RX~- z7uOPY-_eqXT@<6~Ik~a~$tHOp0u-VMU(sFL30*tow${}x1VD{x<9~#8B4+Oez=nkq z`D)g+(X7tnZNb0XVb?WVh@_9fw}Gt&pcFrsGq%~auPO?3p3F-p!i);#+Xx~@O z+ptB7)y`d-zukoV+cY*mFo^o6O|ks65W`^aH0BZH(hx{2?xWUufxO$*KYObI5;Xv6 z-ONbOKTPH4rsdt{fT?U}dxQk_)J&;S$0O-poyREmP!wA}db7ZL$d64RM1P(QHPr-| z-pg_nyg=Jk&(tMrfTe&;GwxD8Ki4e279X6YKDOH_z^M8D6a|tNmj#SgoY0NEn;b{F zoUL&e%Rvq^@o95!5g&`T_E~bmq-ptlrkfjn2goAaYxOgLx_!YUhdA0Id0+P6W|iAc zb5AJZ1}HG5w>Va9Ogk!>_n`_sa)WBO&NE;UC&Vnae{S2PoGS6zY*Q}nMip+mM8>&o zh_ovH>!eO#nRbw{5=-dbDnWy=%w#Zt+(p+mgj9RI z+ocb0eg!iS7%&E6u=)IO9%)0+E!g2ccL;6kF@+G?j%+cV@{m&Ngt+j=|n zOc!cRw)0BVI#kcdrd*IJeN!@m3!$dQB=E>;o;-7El3_pfEwbmo#vmkIw#?8q&iR(1 z78js}r*pw|FCbdj^M@9ahXW70ICy6bM!kaKs;-jXIMjB@OTANBRmW0U zuR?*~GkeOCr|sprO=)AS`Nk+g1aE)Z{#5iUb2enT1JS_MYYjA-oR0A<}Pehg~LOuJneF{PJ#kCUU6aY zd#%Vd-61Q-R7!JfvaO}*53_uWEBP2l9R4Y(2dPrz$NLw%jbG@3xNfuy;y1QZ-~$iS z0ll=bdj|fh9Nl1+560zQBNyT)Z*`043y&*)$AjZTw&QR5I{q-kOOjSg1(4LhA7?7p z9<9h4dH8b{B{Qa-;7M#Sj5FH<#R+@TYJ=WY0KNhHFPy=3{6u287S!eW?whV9T9bg& zx7$>|S+n}T{anEQY4ex4E_DPzBYkvbdKG#Z0Kt;yu5IQAvnpQpp%7uNDfnqt%=@m# z`hx8W2e4hCKC_9y8gjs7GVnSl4hv2wsGg#9Lf2NmxZ&Wd?MT71xeNrZk0Hk2De-1A z9@euyW(AN!Fo4J(zeF2<$4JXvkSBn^NzFEa()SNsY(_j@k%%c8fg;!ZOh?3^(ntWO zME?E2mFYJffl9|O?E_IpP_dNe@lYrNp0izcnZIB^H#0UZ(Z?VH?zLBI(c`WHV;08k z+kr&2fc%;kd(PZB8c6zI(qd+-a*qFj7L)e?Xt5LR5=DbY3ZrxLzAff7hmsAKrv0i0 z1$)2=?`Ci*M8Mb{K?2fCdYry9!Y9z&>{p}}Kc0Xm;oy`%%j0Bn4;KR# zm^rOA%sA_DJj!yifPnyC0TAF~sl^~D34!1$xdRUZ4IV4vO*x~!yCnd4j3=(w#;^UX zw%7F4SS-T9>YPe~!)C7U~(y`V7ni-tae@;9a z%D{xYr1P(roF-Y>2<>-lky&k0_JkV=d|R%!20ufJJ*# z$zbPA<8{+^j%B=SMRiUhX9Va5e$F>2Wi-c!|KE`9pv!jna#+14S`)F;7-gXWqewfk z0xE>b?f;uT6LjzxGV;Ft`VgeBzdx13OuNdQEU(Y(48d$qRM$(m_96Nx=f7gn+)OrR zr#Iq_pKy;X=zl>fr2S1Q_}FMKM-`4Zx*_*6tL*KRPWuhYCDP9E6O71`R-XD~Q3H|K z7w0>>*OAyoDCI%=0~_Q!eDADorDZ$oLz|C@HmXSvHt85RZ<;BLG6ER>^=K4@VDQ}) za0U`nT%%-QI-!8kN9a#F!5>N|j5kBi{BMgglPaQFz(I0TUs(xZF9uH}Ov7qQh-!Yv zk}m*9C*f&QYa>Hd0rv9Tu%SczG=Yw zDsg5yaJjc|T-4y@DoP$n?vY=3E}B=8+%5k$hbDTczZHD$dh`8@C3Rn}*52=Cx(zxp zXv~iPZv+BevjB${c?3B8D*X_qfpTivP9Awg-dDHW)E4%ChhGBA=PHhFmmXJV=F0#Q z#>7|fe8U(*v6h8%^RG5h;JaHVnjRo(Z@EAfL=J;k-zNSHbYZTHrZat%^&w?<$_5?O zOti%H3WE6o-E#a<##^XLd0wm3i`fL}=_`UNd(Y0wlpf`+{<1c)$kS^8m+$E7^v}^7 zQBy@?knHySeL1s8WiXQeJty=Uv8$SIMlJf+8i>ACU;P9MAN(R5Y619Q%RAWQ!&VpS z+6q`$ZIv@QuZ6YWYExKWR-s^)7*>dK0QA8Z`7*NsU#bi>!Y)}6;ARcG4-6$XVdny~ z9W2(r30d9o$g~TaLAkLD?lv%X7Dj3vH1Zl+xRvYb$p)B*o8hxbe_e&Lan=pa>jh&V5J0!@&jIm3P=b5Z&XcwulONKw%GbC~Lt$hmHZkz?$oJOZ-eJVMpe7F@D|;v-$M-ojuvmj6KC z!X%dIT;Tos`rg(vTg#1psNKTD&Sf`5fTf>U)p6Z)`}Yfx4LsY6PyKkuBzMFd6Ee*5 z@6~77GEb;+;*%FX%&pa3|G*C(J~Jc&y7}qM1Ia(|13-wU|NHuL2EY$exUtr99)<(L zy25-32&>(-u#Q%*gO*Z$>|}}jsGQHiI+G+n(C_FB384D-9{yjkTc*FU+Xd~LwK$cH zFRY5{?V4F;wBBo$cOpu=%e0u%$>G|N-CWPc1S1E@8hzy7>TkiW4YIz=&ImWfR9%ky zBxyqbjlvG25Jdi^u$c+ExlmY_@E5G>1FsUlFw{e_#q<6KTf>Z;}?8eRikOChLbChbM8e!j9wpD+UU0qVZP9jWqaLKYD1rD z*c#QEHD+IWQDFaYPr|T}h{dVC`_MSEVs+Qm zL@nUU3ELYrw#11u|QmTbDodqvFzlKB@%Vl=c{HK22W?*>J z?zSE>QX$=^kkbga%71I<<-Od|>#c>sl$VbKsmL#l<^3NuHp`{BuW@JoYRUt%#H-{& zCw)(|(^hfd3Ka75#!s@>v*F+PP4ye5+yqXK-X-p~sHrAHModzb<2uKSql?|u+PIT) z^5_=5XC8BVvA25z$u>p(%lr`_J(t*@8^5=GcBiSPj^>(Ys^1DN{JthtJ6Ry*8L4zE>aAlOAjw$72_A4%pr*H*e=^0nqka7Q9Pke#nfLbG!rnkLQ9r97xX`LW*k9HNl) z+*;*3BKfNf&vD+oGq2Yy#nv!vqW(*A<_;KNs*adIV2o28@DRkC_1w9Y$&b9xs*Q$GfGK9o zsp^_%u|V%KW(XVg0uMnn-Vwj7pJL+*c9FN;=>xf4;mBu7q#Zv1B7Q)H?*J<7)Cp7J zmw*ZruQ4t0wLTft^rKTM62@xF6?Mg@3k8?M#@FTWaq<39=ZT9)b#ap#z$NUIRblb~ zPO(z7FdDt!tv1ZBx`{73+X!=#V5m0vqH6y<@!HS5SvxM)R^2vYp%wg1T1hd4ttLYc zxYwjoBMDt2T_Ze^I~@1nVJ7c+!;d#{C-06H6P=UKkT7m$$uJq*FW+GcI06WRf)SFK zB~Y6LeOC<1=(tz-%pCPi{XpM%(H2ZQJa1bH`Ss+>;Ke+5lm{re7%5Jdpqk*%wz7In z^ka)exjaal*b;lFs6S?FwBmli-x$r~^HC&eM=U)?s&>*0n|7@kwfW(Oe!vR@2$sV5&=i48|3yK39N#N}sj2@c3@ip&o#S^?buMk^ppg*(Nbt}81ajH_C z)QmQ{Lj+NhWr!)xOye%h5D909L6LCYH;*Dp~dUn+VKE#{OhX1cf zfebl0wjSam+A3aKzsSi+jT&kQ2~jkGjuU@q5lJchY0RPR>HU5EQ8fuAQ9saR>vRvA4$l;FX6OSe51t1*V|cq-pM^-X zop>%(J^Pj9a7hjd>Fo}Xh+sZ(OB&*|a){{nMf~a7hn^UZ_h8d?4MsDCGLwA;TwsURnVvQwMxD_1ib?Nx<_eP%VYujm;qyCyFfhaoAJH2nJD&livH$s zdp)8fTlbOCMP}eW_@BZZWgGYu7A#h=WL+)EI1;;BLXJHOEr1mFw1G`foI|TDq}W!n zSuUfe*>2iWpli&;oLD(QeSrO7D|7wx4-AGq`6!!G({#z(qL|&zebg*EugQc14HcTI zpD|$PaaZgv3iCU0Im9dr=%-Zf5M~eXlR5N|>KBK6gxpKf>PY zD?0vU3dxxj-!!)#w22tr%~yKuT1Q z&AXAc z4j>2fTDJl@k}*G4?0v=em-TMo6tTkJ;e|(G>t880RgoZyQzTa^iFOU>K3(AWx=MY> z5sYDgS-$f?;)t*$cJp+hl7=AOfnxvuw!OIH%gA`?miu-@;kNWv-V3Yz7zDCs?GWf? zP!51z-XGLYhdRo74uJm&3cXBC~W3&h2NUEhf`bGP1_z z`|EMpO{9i5Ph?L7m$9?e-ghn72P=uyH(=qEkxs!eDW%aHJqtFr-ry%-gOBt1a73*A zMS}V=u)zktz_jZ~gsKV=1P%O&rh<^p948{<#HHtLC+cyYugPgp{?;7#-!b8Tj zq$qA=7F~5dODjsu^}_;Q&KYzQpbW}8WrTsDt$75sLAhQ3$Cjvk(9j6&rEf(gMI%$i z6S_pQK=5e7daZECEffU>20rq^^{!HJBrswwQ))NdWhT%}MT*F8)V^Ubihdwm zXl-|Y`jY-pJG@1nx*c43t)yeJkY9l19+@GzJd&D~p3kDWm^+ho39ephGMP5vGX|fA z)?OEK{=?tY!2Ffx@^)c7*g<@le2)Sdwj1F*WAnWBxT8n$@ja@R@eG9tO_#tTq-$)T zYi7mong8Pq@^aNM0!aE~H>fuuqkYO#MLbBC`Lf#SlSTL)SkV8()M*grEd266e>CmK zEIISjDdi;K@cq1T8vxm%W4+P5T(t%zSvjL^mX!(quz|BxD`#`vxDlyI_~IIlWAjN{W`+{6hU0FafV8&cGnSj74w-aa@s;12mBn z`r5E9*C;JSXtzOy%yc;?c5Pd90|-GX)D-#U1_K|xy3@v8E>n(+=Fh}t#?sN+{+^*# zrI?m%uUh?e!eu^JpFQ?{O-;URy5EVu4GX#OCCEJNL`F@U8w>^j10 z-QnUJ04H9vp;k_c(tB)?Kiw*$FRX?dqhLKPOr;5 zL@V)-Lr~sOmaJwJyJIRrqsh`mrZ&8qqQRn7qV6rUFdtg4{z7ZP6otD1)$*zA2udz~ zZPKJy%%Cv}7{A>fhm^g5=P)XiP=8df5#I3Z$gBDyEPh`TY&-xA0jTFBrLB85|C`D@ zDm9n-q;pi8Tabh&u_pc&T><{X{v!lMdtz-G{J+P3-Av4j&OGUx$pc^a-cMI6(eQj3 zdFO!dL=ShLOtm4>Qe{r7M7k{t>^=-N%A34@VKGfW+WxVK7-AT`U;0n0Ly5LlrV z4ONP@?+0hOq5EFosspd!EpYVzJ>&qq^2~x#Ta+@ocIJEuGK-{Y%Q|=%V_@7nKNbky zHVM0dU{s9+3ZgBgr(A5^15*WWQ*L*LX?`hW#l`l1Jm<~6F?NVqKib9Z+5oicIdahc z@CtVmd2J_Yc&zK89S-9M(Qs_ve@bwYI&P8IZ>>@G|F|J9J$~6UtsZVVz!(xi{HU*f zQ3?9fl8ddoH?KqYD>PqU>=AR$mxIU5Yg+3SDn@_eJbg~%cL~oKo#e}TlC-*hL zBe|tgTc+0|xi1kVM@M*(nY^r%U@scvH(YH9oh3{8MVjsK2|1l-^StAoegBUTsC<;; zGfhAqzJ-=-p%ULUx4^Lo#~{l-E#~JIH0y+kcZWxB?@!BENqZo9wCk=&B2E9FvfIpM zEo~9`wNh%muAqI2cjX4qU27uH6c4LB+%y?>ct^-_SaBLxRBUl=zEnBcysCS!3RpZ2 z=cX~>5fbQtMDnh6V)SYq|8b`UM=>F6HBD1T)E?0PkM6SnJ(0ltV{T)FNGVo1=o{r3=YvAtKm%l)qZfz^8cx67Q8C1|Dy44(AM zKTnp|#$I8rmDi7iB3kEuZU-6n9_I(zg|JFW*Mh zU6%ONzGAo}b<%z?^=7y|q06r>FGCGg{D7+E?Lw=HFc}mvktlCw&D6tNEs`;Q{vi|? z+TE7E9@@Q|AaC*=XQAYAJ>?h`Bxxnl>Du=END*jYh{GWLYfHDiNtpr#((&o6 zlxU~6<2Iu=psnH;yq!pfqvk_MGM_vT>=9Fcb6XTw-?-g}Ju)klF$b?ovRVJ89<4e& zq~}N}xl&;TcHT^~yhn@(EaHTg`5j_HXVc0*X%;bKJVG9#6d6&Ld&u{{C|kHkRWE4h56@(FT@n?{j! z4QzqJqaRZIfd?3bq!t1usSsF(oF;ad9NrO9WF}k}nJ*Q|bFVqVe)>uoWq;`K6{IY+NLm)FRQ0QmZbJ@q59iAf&5k=|lu z&$C#FW8rM~79782|BBz#d4wGK*Z%vIj5xVs0-BQTAE{8js6)AJ2h__S9< z7!5ABl)0Y$?BoihY;8?*C&h%V`5LjB`Gm?>45w%k4&C!%bz-Q<)tJV> zV?d7mfOeFRL2=PK$Dsa`C*R&1-oo=*A;XTj1YAHy>OMFyR%?4*ZI!d7y%;e|p&}wP zfEvrcBRf(J40L_oMh0C2UG?yfgvv6Lj70r(7edc;coAW9xY^c_-ClL*+J5r0(^9xF zdzg-avqfQ5X7!9z3ktdNsDmL_*#upRs^@~JQ{{_hEAR^v2loRtnW&3htE@bEkPgh_ zj&hy2K7KL$PFXscaTB1k9{i%SvSryp9WQn~9t5au7cOurqsPi&L)T`xvuA~}t2`iJ zT77@?A{Vg$eO0l{1Mc^-_?N(tLz& zU*{D#tJ<~T0e2q$A+W_WdmzGP`z1AB##UOdvA0kO5nQr0{DiAC>onN%*E+9{maB7a z{{hfyK0XXfSp%-c*1y(y)kD^K@oWZ=K#A}xv>$%^1I0NT8=It-Xo8rkj;GEN(8iqH z&Slq4Wa-O!*W%*O?8hKzD4!>?wt=07Pun~0^s|uaU>kXcD1A-f&CFO7+x1p}iq(r? z(Z90!#+`E=+6^!Mvs&KKZ5+OWs5~s_6=+i5ptsGZ7y3sX$8)Clb^1O|g|gYpQ-&_a zrhBI0ux5o^OzUiWp%_A-{;p`FPY4!t`sFI?+c62BnTx`@{`)0_!{O@G1*2gou#trR zDx_B|n8O>nY8T7t0r0SuO2EQJ{yFz~cEAl;TK&Bs$I2$Ri==1b>2x?tZ(|;3%*0~0 zj3aDqnD*C5oz8+A_Zb5GA2VQcgdFFsz-wh@0;3K|*P{+kRu3gbz!WYfFEOR!4T)jY!e!x>cR$s?bI5zn8_S=$oZE}F!11eSqcLDIEe>qY{~}lkwfXoFGQ)LgVqpMD+>>t=Q({kHejgDPupy3U|*NP zA;&`VJLi(!ik87!wk}u`pW^B;6ef7IKY7JWLHqZ9aR0714DkPlc_~+~G#J0@?KC4U zW!bCuTC&h(uy=^^^d|*)to7MYwVxU>8={615$M0Ef7yhN8d~^~Nh2fju>5&9 zNR$4`54;v;NSw`_o5nT02?Zgo;pls*I8WU*@n2cnMgPK^$-8@9{0@wQrL#quq4(TfQMVyd$M?ak0jtMTtp?*!<)ENjJK9##?8R_Mo zY!V*4%RpfuAYw8S0KmBawwCK_b&j}&Uom(s7x(z>r@z*6?aw$*gpz^RatWd~l3vT? zq2K=6QXOY?mFM>Os)LK8NBW*v=W2TA87SmEhQcFYRDWCI1(^jH4$wWlyi3P#Qm{@8 zg@N*97At|J1S197!-R6me^xwCV-%uJTO=088jkQg{tCQzfDtb1z12=V&-LJtx*fTL zruGT`ks1ID_y8v*18h5REdNpa#KKFJLtAzHdh>us`M-zu)rY#@MgK4OfO+*~AhbW! zkYsD|Ke|`{`bFutNJ-%{$Jn$U}osdgsqw;Zs_}u zUw8}kQPQw1SbcT`pnwiy`!eZxiKQmvi}Q%lFXd8axE|~I^+?eAGb^BSm}z7U3^$ZR zI(X0GA=KpE$BrsCKP(NCK4_Pj`De#+pl)f;u*m=e0viwhQFu~=8+Z?InTM)V%X0}l z3Yy-q)nKIE3Eba9fQ7Mqu%cV=Be?S1=UmiI{dQ+87vK8Vfdzjb=$w?o&`(J3;!C3| zS&1NUD+3Gzu!CWM&}*FrV1RH^@K%F=hXK0txWXmE^BjPcd6EdwyN<-M<`C|~TlRBt zmjh_n*Y-5?;Kh@{dX-61tJ zA}J{%oq}|Cr!>+r^w13>IrO}n@VdON`+lD9egFIZ(%+9YYwg*4?c+So<2ctjyW2&a z7TMV&5pR-0QpFWjrohrpXEo(pN!@VDdz3DBHO_@s<&x=%#Z6VN0c{ApY6|tQUjv{GLF{E4f}DS}A^2v#ypRI4 zA)wmgS_uB#hQRW&4FU8YZ3w`nbgZM{shWs8LzVPaoF7NPg~&Z0EKoSGpR>-sn%TNj z*~7~r(tjlI<}xN*VST^q!nLQy@_Z{GM_l5h1v7xk(Z8tdyzplgn`1qo*W`3cMv|peY5+>@?s+Gt%Zg zza6wtwwVq=bgQy6ppxJ=)3lel1T|anI3c)gxn0rxY`wk~PK}by!G`|L;P(8xY&Wpm zbr*o+l?=w>W$|&~weUKL8XH$KFfo#z88p3HHVn7Vh4Yu}v9su~TuJ z<}}x_M=|6;Wy7ZaH7jdVwW?|8uam85Vpk`;k$P-oE|tV)$r!kXHOxu^F~*!^K;7XD)n8p4SkD58UPaqR?9IReE}OcBWi5681*!@VX*ksxs^LKPv)6 zI&;H^w1ZcEE^-vf_XK>w3;poBrPw3BLcvxZZ=siD5!J&@>~(i5ZA&q(4`g?}r;ng7 z>L2}Nw&7Gq$lOs>ao+W$91SG<_lK*e5AWN_IXjx$Z;L{1;|jE13l;^0%IfG-Jvqwa z^dEuVkM1;4m#4V1P05O|6x5Hu^4VXO1po~WR2J6ArHQq*ShuM@J|tkS6))R<)WHW6 zdYg8L&{FG6)|F#A{j83F$1Y_CXf6v5WE+q^Xk z-jg??p!-Z#Rc2NPPyYG=H!%wMO7#7CfCyU~IkB0EOol)YvxGHL7G1yr=j51e@dl#8 zI-!cJ0@)Xql9fPEZ&W<G1RI5AW zhaE&4t=wBydr@z2T11e!v+v}DJ#3j`?4HmxIK~bnH_-l5meGlj^kI)!;S<;D0`|4- zZw{XunSK`qiE|`DbM_vY*V;8M=n(Iz&7L5Wy*K3pkQLGeAjU~9uN$fXgUl(hbz67 z#Mgw6pQxCzvQgaMK%o$k<5k)JB`9R}e*gSJ%k-nBsnRmK23pj8efEx*Iq9i7a(2v)7}h+Jo6EQ^HHMv z1n)#BCp21he8b;Xn-=Wiou?AsTk{||zSNX2J1R`u<7<7ND8|m}ApzR0@uRVWy^z~w z(GGHVIm;<`pX%9oFw0aAilqPG7@wsDJD2}38<&qB<@9;?>S)*vs!`2P+ZFeeH(0Ts`qQG`l|O_K7GP-pdCKl6r?@0!0;SH(i`e-vfeBKr%0U~sZ42ZMXrA| zf0-0p{DlshnF$+mk=yKhaJ%SETY3}-GvIvx;iy7tP3E+M=4Zw=SyQ_3-H-qWx^6FB z=JM-nt5s}-#(@jnA5QY-?Gw_d*|=1#4LfiQpDq9ks$+Oc?@i$Zy=I2u;Q?(4h)rfT zUPQ1~)2pqq%9MYH(+TG7hM=3S$(-krmX(cUAF7PD16HT&e6cyNsz0IXE3`pwD8O)=sz!n>I2W7Y=m_SN!%-{Z{U8_CXLa=BLAe}Pg8w9Zwr;I$xV9(`2MgC- zVmh>OcoKix+m3%moNye6MsCM%C-G5eD+L7r4b>q3OR+JlLDI<@e36{$wE-gVW<3gWwM?n4@uh=P0Dc6eYJ+dBXz^ zn*bR^NDcj1R zQAt2~_L|Nfb}`1BiL9QK`3Rq^E!N6_~oS^dh9 z{leqOv;7AMYNrDW&}uuaUF`#igWkkM@z+0=pcDg^*aDWwivI4-WJEPOCF6%i;x9uX zyy(hL;+)~GCA?q%(Tx9VsI;i4Ce%;YTnehw=m(d#3UqU;B-c(Cxg*m3 zdMXzEDiHc7LP>wV*r=MydOWA-j4OL|t!tNS%DEKjPghEq)&$^2{8qK%_?mko#67d(@=83I8SZp$X48MX|&oQ_S&+f;@3&NbqpsaOXep__#Z^C=T2NdQ;%GU{q&_?>o zfVG!aJ76(qa2-ee`RX$}bQ1G9uM4(lB;N)s>aa2K#i9NMJjRPVr?zXS6XoEG^A{Hn z^0nrI8qIG-3n5}TNYo)nr5bwWfvWhZag^`HkGQry`sFy#D#QAA0XFTM`wh~X`iQ>( zcHYFh6|f)Gk{wMSQ9xzCy5@u(tF~g zBUfjJ;?$4?LEtpwZIFa%9vJVf4AH$Df2oobrKJhIc=MMYZ1V3EW)yueI!(9o_T3m| zwjiN)NL7a>$l^>EactD|vMH>`Gj)tsOL|uPUn%J6PqFS^#8^|{Aj!&qTOL>k*ON>{ z2eK`r8d6FK=C|zgwcSyE__#*U>cM6@${9}r4&q_VZ3?ufsDY&UE3m3($9wjSRu(-N z5nc|wB3xboN!VWAosHG?HvVNBgoE}mBiDAocqv|2^Sf|CAa3)@e(hS&8HCGC|R4>C9_hA2c) zQxrR@npziR6{(Zo+h=bcyk#-Pi0MCYr)^snyKSKq=EONevNp5#){jfjy#9%B9rA}! z_x+<9ri7?7(5cmVba^?$QZ{=Cix{Jb{=>}T4msLoi5jlJSH}!3+1=CED349IK=Ry* z+~ge^qo-cANN~cFdo}*954U9$VCGvCud(B-22cb4hOLHj_zaotXk?s*ecMe0dHa9> zy>*Iq#PEG*-7>Qgw$gNd$Tj*72Z53c_q6L8EcMrLYPL2y9#f^|xYJJDZ1tV(7ksB& zb{5WKu7U1qNPl0v+IfYmw7Pnv%?OcX^tVWIw!3ds^=a{JQ#IpSpR_)@&;Y=c=2Es{sDPNJ2>Km0)$f`34yiiotvOs=Hix=Bnv*!iw+87~{hG~cDguwSGCkb< z+m>Z-zkkxy=^Dm{TK{W?QMDp;``CX$5~X3%W~Bx*6AkGpkGFE*)9)d3k@S$BicAsQ z>*)0me(cP3`-O*+NyLbW%co29rO`SNnxWDS50YV()U!#B;Oo+7SA*Q#Zb*1)r#2*M zl5qSkjZCIqYtc4t(MySp=u{`KlJdf1>zN0)lgr2iFY0NMs6A>fT>CmKd3JpGQb{&Q zapUyu0(fJwdCV~4uvaW7t}npFMrjuY?VI_ouPt;e@v2aDYN-Q0JzqTt%96IdLSJU< z$Ol|xy+fim(7PC=x?P%?`Iwej<`UCwhCM827;&Jj%EAEr+S?3efEe zy^K+-AI_FnG?f?V`H+A6WA_%duNM<$L@1YyJr}okaeKc+~Bf^kTV^eRsDuR85p;tcWCCPn%`a8X*LV8$^wcP;j`q*AD z!VXBC)_hjrqYKdIC*7^t(O)M(CFE}@r06BrR$4oiv*RMCoTdcP{J`S6)E(&DXPHtg24;f;(Z`7EbhJr;|D}JS=Yyf$WEUPLw=cfV)+9=n`-r zwu#5c>)DV|VJPdChP-c%Kcnr)` zON#f!O}e*i$%LIxC*hAG+>Yicy*q^$_?mtNZ-esONz>IX5xJDFtuu0e?V(iKnWfek z_SeAAjlEpgti5su8-DP{ZH<569u3+``(q9cTZ6ecaacp*LHa3X&1id}qboNg1@hq5 z)vMuR)F{zu$8e&&JYv z$8l)5Pft0cE1yfVDMGt0n_ge^U(}SVPts!IKd5QNdIR`>AdL)6Rbb{N^Oo$%5!`F` z8}Af4nonk3P9jDBvp}JG-7jT})sriyqxK;*WcYA=`gJTR7bGR==8NRNT6yBJaRDU% zqmgNULN5^jy~bdN_nk>TDxfO1dv9JWLwMk@JVCb<#6 zi36rB#x}gZKl${)v;`ORW`-73oo|gE>G-OB?BI|yc>hiAXRv|=K~#>}h0Wo+>8cTco}C)mE`#0u_W+9T6F zHZ}-LQ5p;OwZJb>bKrF;TF$pX8%J2f-xr%Jo1ScSWgc!2dak!e<5~G-R=@s545GH9 zRb(!|K)S>OVYZ{5NPdXHGjVdcCW=}$B?ovV1Z98l}gOK6+?3)+l#!LXHb38mSVJNCJ}N<`O~`EV%w=of8x z&(Rbs##QnJ6FlZPo;+CLqoTK-$FR@k`91P~K-c#_zMS(OU7~Aspzt}YWFsIijcvqc zAZy83YnFl0Tqr)n=Qp`#W}h*USBcXqgqG80s@l%Dy;VAmE@_e%(%c$p-{(t*Usx4~ z3nV~?jFzGy8%a#uhWgHKbX;+xSj*$PEcC*fNfx0M0atQ~HBP93XO=UJ{8uB6@h6f3 z5T+V`v@r3jk9>;WNTUW+S2?e%$X7SbJYjna{sMSaY347N{(-&yU$pPWeDnr^F72Ab zVe4>EAI9`q$>~!sp({jlimmmbI8jb7m_2=4EJkj8xE+2&Qy&%|J?{o+DxWdub9G8P zay}od^3P=-(q`}`CK4p>{?y>UH5YpCilrQ?h!J!SpC~-mMlF~y7W2k>p3&d*Aic`Q z3E>Zl8m$s!3s$B)HrBWIXSyNFJX_E34rx5+&Sfc!0y{FkwXanl(d>K8K&g%=oelze z(0)Gnu*N?7&Pb8z!_%zs*$vHRz02sV+GF(dR;Y667@g$#DD1H9P0emyO#{Iib4-q| zvr&^hQde(ic)=T9?6FG-l_gLsGa}i>CZPXFJN%%fOJ&JyM z!&5)MOpMblGC44VUdwRg;SFr@t&VU?*IBp=^$DtX7vIorPGP55B@y}~V# zrFR2A4qSsUzE*QWrFd!oFEEoZ0r@NGC9vDwO;d2^X5K{Y5`Xc|i1<2~YC!$q&e`?* z2F51BXh1{TKRBw;iO`Sy!)uOuIC=g0dO$a0Iw3C7rx|4MoQ@&yC?k4y-|dOK`R9h7 zmL1|5qn7AN^mIk9 z#42%KvDDfdmU_v<&QA+KNmC*f`%4-I5>-PZ9TYP9_g2$2>`bfVvwKp$=vF3*tJqiZ zU2U&39CoNYSXo$>tjup}WH05byK{#{=$*$7xW^n*BnF!$`Bs-Jhzm2^zDh_nm3v=Z zgduMIp1(%XbPAFwCZ;?7p9hz{xaOFoy<9rkPJ=adJ2&1&{@5VYc$wscIt%GzHfNkeXhU_wp#rgTZa~{z)AL(6(;Z;FSWfo26gCmktIeEYeve@zJ+4Tqg7->_9@Fi0i8gUONe5o$0!L^-hTh zL?WjT?u*QNQuN>BpNS$Wbzt$}QbMv%N4t~TEukVO@Bilb0QTwj1LlRuo^cN*irY0@ zb!5oiFMWxdSytzXq#3)=P7mn3W(yZJ>>p>6a|AdB6#Eb#CO&Wkibim+cZ|=Vm5I0(vm0`jDLtnpOOudEZEWEhi?2Rhk}93~!t4GozFV z^lXW9U>ZJ^kfY@Cm#HROc>c z0#BCKA0o4LDsmPs4XjV{x@N@MC-2cv!vj`!R^%;82YOAg&jsuTp1A2(OJ)G{uQ7B9 zjg`U8N*Vc@Q0}Y}EcC9ctfPQ(tZ%39ndBH}g_Jx>dZKJ0)`9Y(AlWu1u$?2ap1H0|f2)i^Q1ovZ&yH^S zr|0yXxsWm&y&DXW3s$b>f`*L=r_QAHhV%CRnKT<3qCu!Feu-EDNGl!>eLuZ+D04$% zsXQR^BDX6x=eJ7u2?G8~VW&exUd`+E9C*lVR^PAY7T!4K_>Z|gMm$b~zb%B=b9H`p zPs)iVS+Cuj|1Ouzy_6uK$^EqAZRx(z+fj|OyA;IabsybdoRz0ze#7WS80aB-d?`OV zQ5j%uV)+%pMgKi_H9uV`nV5EsGSC0z%th&#e&Dc|Z!?8k<3%X*AM?a;D=ar|TbCcc zcq#>{161JS-zu*QwYBZjvHT;Ap%_R&wW+9xi4>AI7y%d&EZ0|}SR^2%4b!+Gt` zqlY{vKBlRU^6#!O+>=c$Og;Nh(tDZX6W!$aenw9`pzbq`P3&*y$qkSbB;+Mc*1H#S zQl%yIAe=MT5zh_VL#JLZ-E*(u-L%LM^=*0s8>#LVqJ`C@?QJ8o<1+UQ=ckjC<=~<_ zt5W`EL+^S~QIE|{#xj!D`^wvVUL#zZW46|z20wV|F31n(aO|G6l+m!PczK!Ps;4@~UyZxAO(&0Q|&^qvX zdA0L1__fD4({{QL2967WJ&BW3|C4ui$C44NWZgFGtiHS~!!1q+&> z-WT+^mqO&bOCj=Y;8gCh#^VNhWgVR>ImWRts=}aQh4U!5-{T3e4ND&Wj7B7tH7H8N zPYPVD7&K*@yn5iIn@f7*P^Y^W6*f~^888R_IyJ9aQ5{PC=v;_&4*%UWLILJBaE4)3g5W*4ZLC>Z z(kVM$rA(cS4zc8kNVNiG;=Lh#?+i==8}NK^dBXsdibN(~L`%dHZxLT_ny^4%``!X{ zI%+SmrN1UVliWADv=0MIM3vWQU=Li+xLZvd=MFEJgf3l7xp3vZ*r*ScbVjazEmaV- zE#N@u`cvOu5{8+B^Eo(FQ+UOC1LNMYmaR0NVP8OD%BicwrV+9Vg^w}{ckgUnrGO(d zyLWUcm`GGksaJL1uD7Dz9QX~Q>Gn^DlS;p@w8ipcJoan|&R~x_Rgk&={mj)V!)YNL zw*n_3sxM;n9RV`?L=`FcdOpv!oTh|A8*aP0(07bkJMQ<2&TZsS{4#+uO>OmcWx@hX zIvM$H#Z6$X?XMlLg)+rSno@o5#jp}_Lx%|!X1~P6iF;@6%o{DNuGmr#ake)|J>;Nv zG7+5+K)9qK|0Q7TXAsYv6e7{%69#L$fi1fAxS6)Wf?OGDM_nt#oC*C~*OqArEN87N zW+1(%Y#41arbsl{O*pCQ``3zC+)K%V?Zv+8?5a#flChth(HdP&_#O8mkmuWAnQLE` zzg@laNmIY^!OyY;BKqO6irO469gbW>(Rk}LPt1F64|u9`x1OA&8rwmBy4{i9z`Gr@ zD8H(Yspiyvq@rDspp<}}Vl|C4{zYiIC+jQd&9JN__P{Ghx6JLs_)Y3tDtBy23&!_a z`Iley5(GOz^;%nd&3xXsVt}Q51?D42*Y=~C_#bUmH|>=!uuQ`UJ~GY?Q8xlsv$NKh zB>PWBlz%w-DWNe*YP&1~9I<|YYi*}(1QY{og$7|~nHn*aDbw~tx@VS>D(iHoX-4UX zEkx^ztBo>+6SL~Wgyot%h&|r1ep29E{U+D(t#+A~BReZ=uetf~QNHaXx7-`%2yD$y8&xR$B-Qj(_}KCIv&5E;T=zh&N^xaj zRvOfRvVLs0p8A8i>*k3Q%{MLSoHxWxO3#-KWdP&)M-_=2AYp23jLYz&4^^jMdDLfs zM}1@T3(z64b*A=L5SH4om`#tFJY>%!L%($Tg?g`@eoYT4?T6>|g6=-u47s_P_p?rr zdF^?H>Mx3vP=|wIdL6}&5AWTl+my?MjROw;1fR!y!xm^7?Fy+ne4Q165t;5H^o&eb%w zzZ=4OUhhOuhUZ#QN|udL{N(&4qk+PV`~XvtliX(217Isw(LIP$nxRXd0Xhe`f873D z{uf0H@pWDcIlLm^IW4F*TJ!RWFNAVD{A0B*SX7JFv1%EKJy--?LZd%$FjC z;g%VAxo%V547G5kNb8&B{q=|uL9uhzANO{#ckSDRSyky)`gdQvEYh5j(LH_{nRX>o zJmM`Z?;R>VBcmv+g{iTxj(aD`!>CwV9bEZ8J%QyJTvY-10YA0U15OtpgiPiU?VC6E zWuD?j>((?Rw4|KQ{5|CSY6yS+-$MX{zoqyzvN$;fCu{cyp>)2Br6NjDex3zNcNbrH zzNFmx7CK1uRsKXk*xmQH@jVE8)!-T$A%+@54>6jh;^W=9Kr@dJpVdqiy~Jj(N6*LK zlM2h}<#_A+$mz9Z(b#t~!s*rme0uuz=h>vZCQ-s%ogNE0i)yR|cvb7tiU$AT=40$2 zCl7*|#Dro}iyxdeD67-|C?47$bA1JwoVpJ14G-aT;SJ@$uh+)F zZOVo|dQCG~3G04ebDu-gGp0rxjKE?eN$>QX9v12j&}I6Ox%a&1n8DscT9oUVGjc+= z2E!L7H>;+X_JPIyfYRpVG`xP92z+L0jpr@okM9{7S6!>&CbQJSyJj8vW)0l7Lc=dV z%wmbeEfisVB&vF6sP7sV-#2h$-3drP_b!y|dPYtP@6BS* z$7W*w7FFU(*&YT$N@%K<;hO(wg55XfUExTvc%3IWPjk22m8l}r zW5{19^L5xoQxi|+Cg;+oPXz7S^3pTd+nYV-yVlM>knO^V2$O3=q#vq-J!jf4t?+%h z5A3K8s4b3C>X%&fM^E>S(r3RFy4?$tT?nUCB@^{guhKSc8RWQ+v?hfbgEge@6^H*7 zzcr`a7jC)b`k$+i5vsV8#BdyDBi4o7X^B8u`-WfyFka)0&OGt!TXkc?)$AuV zJ!+jNMC?(1Nx>)@AyR@H9UD8RcmJaet8fN1FB9EJx*b}{GIdK#C zNdLj$mIjduS!07D&9>hUdJXOV{Ls7&b*1x5mO3c*xcAXfvrC#wOPgoV_S(Z6o~kBq zMC^u1dgnCb*cu#m^JQ;%>Ivp}Uw%#nvftrPqf}ol#tkt(ugi3S7Ba`c4rKI3zBdx& z+`wYP`U>n+&tor;$4RuvVc4w~_yH|)Acf)U;^yhb1ni@j-}cdw$!^Ap)2VxokvlF; zgPi#z`)Q~53gO9JyE3WymyGo%z*rOiV5|*iGCfl8-ZKe#7Rb28PppGa#UJq=mabwf z+!?n23YblooSFSMXSN>EJhVd@c5tUrK-QX=F^E^_ks~oL`r4F!#>Z*b7W95!76h6W zst;NFaK>M(C>XI-A*i-+y1irPLhOL|-ioG$;dqujX>I!gsP)>ug?Ux$bxmjOk3}|r zPynRYQS|2*Y^>deiwzHf0bUpH&%M*vOy&p~m4&$w|k%2FVt^vDPT_;aYnPE3TO?awDijwx{$32`{e9O+z)am3!O!Or;4DAl8y9h za^@{Tx*Dy{gdX{ly$|(z(q(GMg`x|Hqy(A*YTY~&D-sQ%`z0-=Kk(NcglTzhvmB}s zP4o3@%e#-}_NI;lf30jSv9u?9%>!)NX8OkJTUta@Pa3rcf|=&?gNuA(LU!Nq7MWHE zDWDj>`uMv%OqPggF~61A!ULejeDNAywI8QwJLuc0SpkChqzzKTU-23e|Iqjt)M7X< z+jTnJCDFRElDU@x(4%nn+672v=h0XC8$gD!{e8!*tI^#-%XUPFu0-KriG`I%Ka zX%l{kU{R%Jv#94m)zrpX4(2BfHuS8c@6K{@CEe6ZYiS+x;-hk~U37hC=l$7IiAYCZ zEdH7J3RiIb_TgUBAnbv_ajm|jjVO(=R?Q%+s>%r#jR{1Evt}W)nX`jISh0~(sE}{# zcFnQ1OTqQ~2A?^Gv4-C#IH{ApQ^zmJZN&L&M)* z0x*>*LK^2gJ&8V_bogCMrDv5@UuIJ$HDBI%+fxqcB|bpvJxNPuX)jHl|M*3e?j>C3 zTUw=k`&T@eoQg1B{Qi8@Pi}5z8*KWIc;F&FFaeUQTIp7u)>N(#{eItb{5Fdl$`M6F zkEiE1r=3;4WVfs7v5|Rf-+`VboMZWYht9ZGI;mc3d^PzN9vO`u4vAOMK%nb9U*cH> zo5<&UyU%MZuemB!o9a@cO~Vh8x>e`?wZge))2vfb1Yh#?7r0)bu~^Vml1%)Ti%5Lb zjfA-|p$7^*H)83ebAvQI@-?k+Xtv&0IMI5d{v1iED?a1rKGA|9fkA6o`PM3QX|uGn zI*6JO$mN>w8;cS0F>|qJAz4FXw<62HVVxl8$=JzN{3NA(zuZVL!#}N%f=D#|GzF2E z_+gPL))xLYo5GlD<;IH}1ih*NXnx@lSlwkeLdWjb#&eP}mN*07 zIbRpHtOH>B@Diq5Vf(!Yc0*M-AM?Ha{~s{APhwxcmw@8CEewr{cpmAgd((NXf$ZKx zjQNeESLZW#z=b4pk-x5CxjaSut#OEsw_b!d2yM~v>QQ2xwY@hgUjm_H!C|6LA z>f)q+=%VEXK|5Ezlm&8{f&dBQ&4V4)ovIh^^m%M0uP>#J*(NQa$n!+-EVd{-0(eV% zO<68I{S@&}-;#bF3JrRoD=!8Axuf3PnXRbfR*w!i0yGEX(tK;4o)Ir>UU+jnz$K)yux59BWZ#(slWJ9Q=BeDv2 zBfVD*(h+_2fcR7yYdOo1eBx6YrL9rPu152hpYy-^XS8q-&C&hvnJRNk-Ll$0ec=~w z_F4HeF|t#u3U?cQXidwJ3&?1CUvRYiSKsomm{|iA*L@GuQrSFnx!RCJA?Akwc=94v zJMArj>+@{m0=qa7w}rPZl*115Rz3GX~D*J==oBgCwS= z2OA`WD~PwnGJq27!nhf|*QZkX_XP~&VLq2(z<_dSIncKMVCmgVY`ACgQ|izk)<9TXGob zil}@F*B&$KiEGe0Q9As&KG0q`<^~X6=m^f0*$d%^6ORrhx;Um~(uvNEZadl!+x+0U zp^85&O_TVDd6UmHhQIeIC|5}QMmU}*^~q-%nCQ>lgYpr}{$!)I6`|gr_NU{pxtTGp z9S?BXd(gWhqtusSmz-K@ikY*St_w-zcLBN~GG83MW?5&~v5k@=cq9+!Z&n@3&$7zF zT&{+?P5KA^7g}0n+<^37Ow@KWU|+WNdWF#`sHwhP>>VH?drAA56gTytqj3x1x!UoQ zqF-eN=bz(JS-9h))L?Uim)5CBHJ?}rx-8sXHH!v1EV97_y4}^K5iDdM1s^| }~ooO3m5Ni-4x90dyXwk6W*0YQo@vBFBF~v&H`i&G$zU%o-1n%?^Mc8oNwvZh)D1no$vz zt-2-+%iP?!C7ZWYxw88OAj9TU-Gqf}AB^f;bqAgCbaJOQDT%fDo8aDfCI$BwYR%W5 zZwN8yUxXNdt#{2>U)%lI3HK;5|`U`sCz9zxQyDP&>s72U*$@CQScUWHu z@pK3i4}|k-|4E%;dxw5XU==wnKo5pVRQhhARd|PLN-qpw>A}Uz>PEa<#~cnj9p7g}QhCL|x;g#f9V5 ze3k1BjD1*~FW~oY1kWh;?+XABT-_uh#^P$DV;}AoZNh3%JaA4fMQCd!uS@p}pHT|) zT)!L^cA;4L)QY2N6}E$xj}VD$ZICR5(6Ck4-TdY&xagMXg1wK}|9@EXM!HpYug~j_ ztl$UklIGMG!;VR6JlsS<#bM1OJT(KYXX0W$++Iz>4(=@b(H1|Z?TCeKg6cSzZLPn!{Py?JG$ z0r`@5^~8q7YH9}|204=SFV$#sx#PHT6^&v#m+jgw=(QMb*tXn?f@3bbr9n4dIXtG3 zaIwv_Upvj|lSR>aBIB-;#A$Wmye2u$o+C;2Ll-vfT3M%jof>*T&&Z}^UFsJiQqs`? zyJlg86?_+1>zdHkWVx+dF3PDDxFj)~4jN_Us8bDox-M;w@6NLzXF@@y6wU>E=KP62 zGn10d&rh~{{Nny*hI^ZhzxsY&!zS%Eh?6ZK{4eI|xxFkk>cM2>1JayE50gPM#Aw_n zn)N%|!^E`g4V2$_b}gikqFV#l`N7_W|L*H6>@5C`oi4qaVHZwpbYBiA-VpYjD^R8W z4l95Hv1;iUeG;eC8&%S*rcCzwcU(E5fX5?xeRN`VCP54RLw(3Bfy{sYS5yJZ_`or# z#fyc!(Nn7-Ybr!{f7t$lh@{7(&&W{?~b{dq*AmUTf{wRzKKPwM^gR z**?I3>^l5K;)aL3iv0d>0mv3gN-V=B1?g79&9<1nQ;%-QUOsd3Nc+|8Z@OBExfZ+n)eiuWbDDp9ZuCXM=O^w*?=^{BjQc14Jf`%v+a|rrO8jN@`}`*d7mf@K$vvCqDkrHMYhvRESyTe>LXr-57HL{~yNO%#AT; z@V^;zp@$~UiJ{x-Vj?#Td9?#O2vazVSi%qHZIn+W+jt)+UkXDJ5n&B zgCbW|Nd6D~f~J8=YF4l9TEJMjJeqeUU{E(a!h5e9i@eyc zQn=hBm7)faQX%bBmA6$MG)8zH+&WvhFyjvnycN+=aDub6WO4(?{w)9<^qQFr{c#P) zkQ-%kV`9sp_(;*pLgu!uhvaC0oCPBdrX(HRfpZc;=O9Ou)eNSrrmW^R0i{(mp$=CF36=&~jKdpQeWIeI#L zmxTYP<+w60mjk!oXwuiqjf_j$zxda3=OFTPML$;RkYXio(+Znr>tVL_TF1XN2pWS{ z`~9hR`!2lvOnFSHcYqxzX^mXS@PQt21Mvv7URv(hP+8xfBXoFmX6H=$_5~o>l$wVg z3`oj9)5ck;xX~P{%eS{@JWO+w%zF;CMk87H?I_KSI5_q9sVQp}RJgDF-*?p(LN+|+@%*2hqF(Xp^MSBKA zCr2222OGCNoC?JtT`(m$L^X$79f;oJ4Lx*QUsfh}J#<^7z_{ zn5%dTC=cC~7qhaUPoSwhAMa;L~jO%mJ$g1p~%hmuN6f{i^$x-kc7(vuwD0{Y*k! zTwcg+%R6wg0h$h$bs!3mX5*armhCm0o~YKYlZD@q@r!qUbiv9f|CF&e=8%=#n7%-` zmBD(rm#1KWvJ2Q%*+s&iWfukO6t_lQfpHNzW30a=mC0hr-orDA)juSajABB_H6bsn z{ND(99*H>mjO0n*#GDAljWd#YuhGgy8`Mam)sBJ|1QUCCDSGRXUmsF~l?A1`Spv^n z_*JfhR+uI38vZJlUO~h_9^yIvl2OmPK&-|7slU3wh7xSR`x26BZ|4%vMl@;OKEt10 z6+s)pPs{`Hi~JtmuoeX0{_S2?696EE+IR0XaANZa|S`kTNOg z(@rq|~8> zI~UPhO$P+4_bAZTjUpzqGB!WKT6z#Ms$;7%cRjsFTsutGK%F~BW4d8+;kipi!0*e~ z<%X2q`auE;er~OqkQF+IuA_>k{J_-vSLh^n^|{3qXUG6_sgdeSDxXMsxT2U1&x6H? zj_OZ9XmcZl*Acy&zSIA>+7Ar~7!&P|K9w;qa~Zbr=7*-8Z8GqA!CH&ZMR$j3r#ZIh z3~PAWX@7Zd;KyF_ZH5WH4qZs=hiNVP9s6=Y8 zJ9CeyQ&RrG2f)2RtewvxhD0<7&Y!-W(;9u2((S)x5d8Q=9H_XdV=M@=BwdBbYhg50 zN4KeQ4>9-C_ipt#E!l4Hz_E7sq?Sk{cWP~_)RUFtCtdcsRz}}nkStP9hKEQzI@eN@ zNUdX#^a^n&ySpD?>tdyKJjK`B;8kmNwX{t^Nl@{<;B&gT4^4V+gusCBSF^k{nXlu_;@;Vi8i-zo$5!X}C z*F2TnKr2AlKyfs%jzWNkSngM8XFic|=xwo0&b%uB+Uq^6NB1i(_;i%tHNf|`&(o0V za^lKVdXI{KrFAcs_V?KG|2{VE;1T0jV64%yZA9{Q&xPK@qW?bjRKd2U!yIa`;*nKD zW>5|rK*&FeXti2Ok~ph>+U-1+K)DFNviq=ubM=HkygslJ^K@6=hmt^ngUl#k`;)^OcFua()V+!P?H{kMD{)T{Nc|$?&Cj{T>S~WKa zfm8z_rfmeL>>N+|~3T7jYQp3X>e!c~X+$R;_h>>HX2oWZkV=yep4@ z^jJtX$+pCN+qb7xwAS>cA9(@cMw{c(`vOAv9qav_$C>yv6R+;e=DyRrbn{xtBw+PY zpNjv>;9qMCn*C2@N~5#{cD#IUYC)zapFZj0BEZub_l%}dHMCtM zi)TP9_P7Pl?n;S1)3GDV`AR#f!O)TuX@_QQKw)r$R2HI#$kNRD~%&7}usX&PXa0yz-tYQ#vM*f~va zpV{|skEUOEgI}b&1u6U6i`5oaD*D4)DmoXwN+<$|au6UPJ4@8VcjERGsQuDBbGp2< z@K1ZrmQr2_?OwHQ#G1{uDY?W;5#7NMcoH1u0oR7Z;3vZHtp?!VLx?ueQsUyYp#u0N z3fDULNz(>cR;$5%|Ky+q1`V%wKfD0`Q;<~WcD}iF%H808cz93}T9D-CdcL`Ey5J7q z^nmxl4}{?j@D*6n2_x`(?iU^=cZVP&7aO3Q2DsIHJp2NT;{Idm2a(HukEDg$>&>mS zL4qEzhcC#vzxrP6t{kou=BB|7;k&=W^B6T<(vWcZCeZTTq~;onUC{oPYWkmPYAaiW#Z-oTBSFe1Fa zEP27+T+L_g{&+a+V0PwT(|1P@QkDEMy$`a~MNM7cUb{zl_$OWAQm!0-s&DsA%=CqU z$(@@1Il1=s-SUF%&dPctz1jGefL>i)SN!oS{;+?F*RrOMIEG07>t6%+uMbFf5crhr zyE)?o?x@KGFbP%(JhwRL8PKLI#w{PUcFi75KUUV)ddr*@+%c;>JCcTq@&@TP{v%OU zBSJTU$Dgfko-gzv+zCo2dwlNLVgCh@_(bo;^`ouUh8&3@4xSIy01Hrc$KigzDdUi*_b~&}4Puogz>gk7)^1mOM%Vm8z)IUGSR2mo@p92gQz8Xy9)3%hH>f-s2!H3;z zKBv1dBQPC{)+=so{L#?CO2BQ;O-{fkNowbYHXYypmH`z&1L2+V?PxiC0$iRRRT)=t}31QSYL?r;~48ju{54%I~9nZ=n|nnIPCT#%;wNavb>Rvq|JP+7CZKeJJjAPtj$>Xvy%g;?8D2eBTHD*7w5zE`LD?j z45EYgD1AxRl|lp#2_;2o21h&G)tslQTS-&To-gZcWg{wH9fNtaIm>9~pTOm#B3Zgu z;{VOBI)W-xuq~|rQz>V0_{Xf${Yt(-3Fp&KKgIG!FsNV1i5TPYjx|XR7?2-B4^gt( zJpu`xGu3%*)ZJ|M!(XgEpLjSf`zlnu{OIw1;2=zJcnXP3@Y)cl8PG%s=Ryhshuu!C zQ%WhT=RJA#oU3{CVTkO=1P5&H6SKo7)`}{>-LbZvmF|l$HTkeOSZafy6zr^Jkl=Y? zTtH9wkPu&=ID5KHQQz{d>XnWlEM-0N^kU!)`FgG#7()w@HH55_eK)qT4W^Ve`!;rE8w@7KV8(WzGuFP> z=en-n{dnAe{O*5yoO9AR&*Oc(U&r(HdW+XYx_6*kIyjG67}f|R9Xcu6qUbqZtIv8a z_v3iBQK&x6S*-``STWL@BBk}S+*}#VU?h4R2Tu5uXf-fe={D8cLgmeNLR3i~N?J;5 zmQK;Ov*aI__~A7+?{m>`A2O|5T%`QMxj!SKg(uz}qC}Hmm>T)o{Lejglckp`aK7tt zyhAIFA74miQeYF@ruqHk_k%-cCAyADkn+37E^Zp6n_dt!t1J?3J9g(c ziH(atn^8g8j^@_fJ|!AdD7)Bh>+~tA*^KEr*=@^A8LB#g*M>j%Og3{~P|!p7%i6KW z1r#zCu_)gA(DLTfnY^fX)&(@HCw}czZLi4Azy$=TrT_8`lI7h?+vSNP&Gqmf>RcfC zU}DQLHx;3T4XuF~R@u*3-P$-gRWLuSp5U`vUR7)u7`f2XRnxx<`y#GVA_C}S_-Itu zzupqO;Rgh+W9sFrla%5cM2AhepJ&~=01Hl)_CKMpY2Ckz0o6!Z&&hI;%LN@g6Bf&bRTnR)3B-~FLC zX#sBIUE4_W=;hHi4!m@$I*JK;OIwN!_b&s+ z-~|(Kpa4AEOHZHA>K5jdj~UTk;w7d0s>&;8iaRElRv!B*^i58QqT{lPX4njc3VcMY zXg`YNl{hz}lYaZsg=ZGWYEsOtBHcYP%!>?vX71eix|t00$}_5B&nmLqjGn@BprKkO z>zc2!M!#y<9r^b5$q~wPFg^Yy0V&*a-r-E0V^M|9md~U)fWzH-qe(b@5vo)A;=ws+ zspA9S`Y(5B2z4O2#lwFWYCOOg_GMM{l|lmSe{(t1A6dz`0z6CSxo$~PF%M8hBdm5- zw4r=_FsKvNE-RSquE5cxmJ*!<(*_>$)DWo=+m_byuUdUO&()H|%Gg3Yv=K^;8IecA zlcKz6ECvD%zKtKc&Sh#SBQifIGchSfS7|j_@u;EaeG_W24_TKpYRM+Nj+nTtwBe2G z36Jt)5S6C(XbMSbj;_P*#~+1gpcxEuUT-Gcv1AOci7De)ED5~1Cbv#0#Y);;h0`{` z8ZY0CG4uU+B9}rDA3E7j6DkHtWWER7P0;8i;r=u@iKNy$2B+U;LZ9_JT zq@LwZ+=}|Fhht;}6I|uTGrBnGo@~WcjE;1jxwGD1@si1%;rbc!hm=zS-&dUS_sk46 z9(j^?3kp43&#>X)*0xga<`$l<7q^`nB-Cxa@60gv{ys|t$*hAvpjNh9`}(Vv*!h zppHIK@e@vg+W(NcX@#^{tAN%8W_niA1{dnoCRqzqd+;em`tejaIU(MA9H;JVY8E3h0cCY!!ccgh`%GWYEHVu2j9Ua}gGprfRV|dFm1+_axf4!yOtb z)`3_KZD634`B|q5Ju!s{yqhn8#rj1pxJyiD{W|QKuTGO^CD1UnqlVTUksm|sR=B}n@ z4}`*6eNYX{$mZHB|4mhUHoz8NlFnY$yVFEvXXuO1-CENk4Pn9PkqbZ_e`G_K&1|%% zj;AlQSPSHT=(9G7+)MyE!{d6{Y4G*J)G%?`ZtU_%8;7#>3-5&7kBBx)*9T$AxY_%m z&8sYI!#i)a6T^$Sf|&)A$v`XU1r>+2>eUCS0`*b20QGp__kKXr(|A|7ccviDV^O(5 zDjnQ(<_IUX|0Or-NUhf&`9^I{on7lY`@!Q;VpdShnX<@@YcoqNPslFj%?$*ulvMSI zcCy)AcyYl>1i2*CSa?K|w%zkqCxTpN?#r_wMJ8m^LaU4x1l{=|sg7bHly8d|XKMVW zwBoT1UdnZ9XzVh3A4it^h10vQ*U&%^%@XMx^eF8Q+Tmr%O}stkknXf?$U1jS?u;4_ zDw`lYt}B(RCka-9WMu*-J~fpyT!91EO7VvsvQCZF0>6pNCX&;l1%(tx-_068+qT(H z){U{5XV?U+p9=ENLA)P%f)Hv%RpJjrd@CI%;}6_@X}^ipp0<8Eyxn(Edx$x$#WSxJwHQF;u_99Q8Sp3p0ID0X8Q&z6bZZSg%^N%Ezvs9KykGU2j|< zr7Tzb-4}NzHAIy0-e}HoaLVv9@sIi^zM(tQh!7V&R^+rf#)Mqihy25KE4zHL>M575JQ-%~^)CdGH&FoB zdGqyF6w!0uqj!aT7567V%I{Gc=SMVp=p2ZzT;{S*Lk%+H+{4r492ol?-=!xjKR46` zF|?9m7+IRTsTMPg4G94+Z!zSlNBS$(wJi{y<;*4eAYttI&id1*RVnR-Xm{-`4VJ*K z6ZtGV4}11AQD1XeqECZdmKsYkrCAg0uBzc#3BmL*{YhSzP@yJ=AI9_Y0cQ~Gz5O+v z)zc)I$(2?ZA0BB>pfTFS8(!pmlcfFfSWk}TDYjFoJn-dz^w~cAxTX5o4V?+OlBG75 zK9@DTp1a&)cn3{XTgH{^7+!}3br|Cn*rCYG$C2J(0uDRV{K5oK!3s87D8{$&hEd^QDgy-B(h3TU>C>1_W8_5NAN3UzI zG57FavWO#5O^Q$IxVv#)%dh#N7u$_}h+3bW4U6EN{|q|gBa9{CXQNMBH!US1q)p9O z%$W`EOo)q;x)s0buM}GJFxprKzI?8$Rz2%=R*PwPaE47;O6Y48O;hNN|a{(KYSbA8cB%e9aj^}0zhk8i4vh0kJ5 zS2f71Q{;C{Cd2lB#Yy11+dl)_+qSBb`)g>8EUyk8RB(?$+*y%`bT3qw(`$PY&brlhLJQc zd>u3#ZAk$6f{z154amX794!e{RNPq6s*zmp`;6Z#_kB|#39!wF)9t@0_pLy=U#m{4 zvCB3`{4tIT5X6dA)WxUNWD@q+xP3rv4C z*D7NINICDl&GmChMIDwJKP#x%h@k$fqQ^Cn97C6+s8m#Ht&f+sX3xJr@!f>I)7m6> zb49sVUNRs(c*tGnT^pXLR;V-{@LP^~o#;XnO>8t=X@V(RMd=Vdl3j z?^GX@heIYjR+lBdkTgEQce00C$Ktl6nnn96mpE%qcuV1defth@?tepb{5QQdsbXhe z0v-YBcfw({75z2=oVHj2)fC5un>l)~cKUXR*I!D7qd3umY>0?d>RdV>)-tegk=P75wZw&AGrd z7_8&{Z9gS0;@zuEmnGc2a!5`m@&`-D&T`-`^cjf#;E|I0L5T}yy!R)xvU7FKwfDk$ zTF0mSAxamIhW~ulXC9o;a}wyBl^9p#C$xStI4sP2_M=W06HSPm2dF8rG2)89D^J|Z z@4kGa6s@qO118m!7rpx71Fv;0Lq>kPwV7swd<8?Mf3f$60_B)x5}dX z4Vm`#+*1rCev4Nk;D`*~ho?3dilCy*>vwwmg(1?G=W1k*9d#&Y^$~IzXW8@YW52&9 z6eRz_)w;?+%pWss{?rQ*<9$W!H%OtN&6Q#eP-BdI-7D91Nfqi@y(m6>(cYSmT&MlQ zjS4tZtd{|EVIJ|e^vDuqf~6zOX1|}-pFU$4Fd)ojNKXRKmKW3%CeJ!3=7M4FMc_PC zqI&nIfHQDTX>9#V0#12e>#Gf?qz&s_t4ns|$uJJD+11pFa1XAxXOUhPjj32N|12{t zEzDIJIF;uhQV^2*i|;#p65F`b6!E==pZpF@CmY~L3jzZ)@2gulCE;}X^d})(bw4fp zNdXOzRF@mhu_)ROMBI4O1)wp=9raE{=*(k2?>D%2Uig` z$S~;KdnZ3TmHgxUQY^#9z)*Wo^+mS$kmB*>T(O;J#xAg)Hlo+i!XMAe_4e`ck~8F9 z{eLR-_<-<0j5p`}9oT6WHOBv`&L_O@Ij>)5nfq8X_95b}u}K&Dobcp^OSi&rfj_dW z?+oTswzQ26>;2E>F)rHHSu75E6F8MC<|^tfW@iQ(ueiF5cIFoHj<3fcYg$%7z5}O& zDMNhBO^rYs9w>}u+MtYKOm<42^*^hLt5b1Qb2#E-MfSFUlK}_blZAGc;aq);ZsD3Vc!!IW`5Tx;{;&E2j_pFETctCi4;1kf?+@|Z8 zfUg|(ydgBStsT0VLY42BFlpM{yknWq^=Zz2F;x)To#531=6D!-iH>e$Qs+)$cby)mx568yerXL-t=gTbYFMOQQ3(-x~j zR5Mu}AVz?Sk$O^QWjvSN%`3lQcLxK3h!f$Yve+~P4&PSy1n~D*r;v9Og2|>ZamODv zFTzT8mI$Z~NNHUah89LRLiI$6p$2QIgiw0mJCdchimC}%KG1Y?ch`WMajxS-g;*Gw zlYonzv&k2KB41ohZxvD#P(1x}q*X5HbJCDtfMoS%BJ5C~{v*_%Ywr5keIvN*B5#TMlPW{vM~gd6JlJ|ZjxE)OC#>OQnM zlQSp8B{YVS7bV&U)`~n|O>eTu#Wm@`Sy`8=So1r^YM2~EvM>)^852Plv_nLO7}%m; zQ^s{u6W17gXDCMLGXt*Ev%w zKUuOpC=ZsT&Xs*%*qcl->qkv>Ga?+;U=0jkU+;O)^bC+2I`mQNQAx)o`9YkcgZ+T#ma8uMLH>@4rSy2^bz z?Rjd80g` zZHeG@JJ-#h=f2imvFoCe?(`M#4WWBYRE{<$E00jp_*+XlO9$?(lwWhrWzxQDeR?-d z1zpzZu0N96HsCVvSR)e9T@7=e9w^C(vdwsjopMokpnJ%DzlyUlG#YJXss)YBm~k=88^8cDGJh0G_O3;0w`{OR-{r z85Lc8exNMvm#*{drNotvg&X2YxOPq8?L3~awmL(4?cjKHj3bl%PhXe2D~Eg_zh0@h zc;$X4L~b$1N>QNtP;j(;Ff{+L@vplyfz3G1Ax&Z1SiO1nvZ(eqxi1FVEn+ z41KFZi5NGytO`#~$JvrPpaIG^8FHF@dTO7@t*Q_Rz?lIoF4k-;Vizy4BHae9dU=x- zA@2szd2I!HcYCzw@^>eUPJqm9nq?wZf?JDlkmwV@xD=k+{5FAOOC-*dj$PWCLS2O& z(7{$e!g5TO=9)A)7+!H{3~AxLZ9VW=V=lILOoQfdSl4&+@b&(gd{AY*kGX8;EP|v4 zf2d=Z>T_yMTPH@2^#Jg78>o%fsxvb5Ub#S52wh~+U704dnAENk;!2uh1#zj-Ws*}% z-4~#KK-W5;Y8tTW5EM6{g!@(q8+>O0DvzbS4ML?WlWVI;5$He{F|X8gCJD$%zp^Ff zg6&P08X-9|QA@vig>5_}twNf`0%j|mCnf#o?6k}Z78`(@1K;t0s%31nV{6<1D{ylV zaC7&vAW{MORV!T?(K_pdj^^X??;3oSB_PC+aOfOuw_??Jof%^cf^M(}5Q?T}-gWg{ zNgkwXj$a=UlXu~6HD(p3jZRN)v-Bz$Oj>G_(4K*s>?;U~AHi!hvUZWaw*PcU#2#Rc z#vV{uh~$U^zt}wF#2$sD!niqYeVZ0{@8!WxXZgGUipA1G1iLf%X;+1#|DZ1m!toz0 zGXQaQt@LJPTC+}}d%`}VnsQxM9o~D67$T;lD&!1&tQMHI#3#AqNj!v19qG^B=8zIC z`>hdUO{b{O%*ysPpoY6nTqsfB+t~3^jEutDMYop>7Scx}V|rqnMuOMRQv1y8XWqIW z=%}<4_D;+*`xThXPtV15dj_n`UsoR4du4_cGqO8y=6zqQZCp8PY?aH&cg7}#Dfr?< z(BZc(V)x{3@1yWG>o*b+6{Km00?Qs9!#+vCVELKn@FM=HtCvUyaVG3ZmrQ+i%=9z5 zc0I6JuAI#0o*IWvYHKnPE2fIW#x;P3P=?c2fT>_$Xj8$i%8s)|v`($q3 z26r+GqEi z9{pu~{C8A-bWr;<3zY`b{S9g(x-@-%{Uv!mL%vLeZPtky7am-o0VtU(Mo z1LUl4b-u{#K`Xk^eRisxin ziG9!hDV2Y^pyjbE#HbLTdjZ7B&P)v5dAiOW0~y4YiafRcq?*zZBBywrEQV9mSz&E8 zUf$~!>IObN9;JN|oAM(t=46=<0o_nMcGQsBd9}ngn9Uy8E&@~9y|c%}1=TOHm#lYw zkjcIeqbPww0xBvUd0<>a-eK0o9%m;13DCv0*dTx|j;ya5d%$hQUuAi3VCEquA$`;< zm66U{A;JUDgYQnxnb@AX1pFkLn6lJXjrhGXzo(Kn5LfcII(|8LqrN12mRO78c>Xn- zD@_wL+pIC@XKI@aB}$W1Ya(R+n&o?aJOk zXNqO>WQHO9cRT+(1t&qF`ptP~%goWNKoBd2P_(`Eu~=l*okQE;EYJMR?04Q0pYF=93+XVYTjOR8FO*uLA z<(2x+?#h-gXs;90F&s)Tkr4DDSX=N3gWuaTI(?s4 z1&V_$xWQpVNf{c~*l+0klid9J-LU}hKSnbSiT^C>t#y#j$~|Yd%=*2onx$yR8oO+e z5`Ff^Y(n`WyllnH&YiC@!>(eQFO6O(X)V5EQb*&xMaq5dP=kXSDz34T!wCdkLgUkw z(c(z1&=?MgeDS4Py@LhN-zBp@pB{XA!;@gw-(CZpqC%+b8tia){iq%E9NN$H1pG1g z_4Vu3Q2^3nz!p(BfN&eC7?tai`h7^gk7rb+=$v6?IEP|2!w?dAMO}6r9kKuuskydM z7EKv~&dzc;J9ISl<+~n#)8cGT$PIsuTC_r2>zCCb-#>fSufk8BgH~P1RzDXV^84+_ zV~^$U&i)s@gl>#B;{3?S`w;Yjd|rnONw%NP03wJ#eSSm=vP8TX<4ITO{QI4SUh0>? z@`Lu)wkz?HI0Q}+Kw&KCfX+EN@vO}wobmg$e@eFnIUl>AIeqN?kRJ}M_WYS_9aWLn}qbvfzDPOa*XTc1la zJp9?oME~U43BDHjU20Dl1{YP?J12CxL=>z}UeCA1rp@#31nJ!q_vdKI#qchwXABpWAIldA=7v}!Ppe8kfp}coop3o! z-kUF)YDOcJOZ+Z(wk{5;tAWU~+RTsT087#!Ta|=HIP#Nh#vP@%NRp<8{hlst;71I3 zYb{gLYylpRIv%hi%}T_4+T3U*{+iHo1fvLq0DCL7Sk^0@W@A;on>-+;KKZL(pbuB= z(=mo&;@G!n7+PA@-dhIDj;qb1&*Qu4vKl#uf%h=$)_K_5To|*3=5IZbguu9OsEYy3 zTRt8K!o7J5KSg-9@VI`UYOKH&`V4{*0L4@4wvi0~e7FDGP~WgacZGN0luH>l@UYS^ zfn+rB-^%s|$?m)4L`+TJo7bp+kQuBq{8#7feDM55ZUL2KwiLS!o5t!?`Aa zuvM{zshGi0Z`3mq?iZ>P$~m?LX>p?9ic^JF8u%S3Cywto!{(w{|8Izj%^WnMtN4Z^ z1yLzLkt~68XQZgi6FI*i`)mAy`QDnOGilj0EicDv**G*64o#o_FlJ3_#E_v!3RDo%=^r z<*96zo0)?j`wo0sLf1?%2tT_)koZ)C8kl0K&qDclpnKy-5qtp>kHXI>m=iy)!cEMANg!p}bM+8DU*r9}Q`@ z_`twy$--bdG{B4}r54h>p><~%O38YIgS?5tlgceSc zTRj!^TJ?1x{`%Ln`tf5DN2D*>vw)$NS73I&qn=n1INth_&_p-^_{|>!kl^@#fdpHZ z)2T+VfjsXUNz58Y!$Q^cHT*o*u`)KVbwYOdu#NKXDZ%=7dfLNOy`G#|kFaSzVNc|M z()5WwFZ>-+#6!v5;)+xTzs*D^Y|7eXYv6c1DNyNQRCVt6WW7ESjqZvL@~KsOXB9{> zl?04n;hC2^owFEis@uH5fM&-=ISF^z(}p8-a;zD_{*esyQNDP8TQP})#eLj~5kHSn zj_|3aQxu?WM=0waJ6{vc!Evrf&(ztGZTrb`k~3TN`_1rICoKRw9KHT9=H=vEG`3Xd zhVX;*_C8-+z|}qN^dYy`YdbH2v?8LWwU61<`qWuy;l-Uhb4)I*x+wm|B6=!ChRdzx zrr1amC5kGeLZ2avmS zi^dmiPEMD{%2i$d8k1fQMxnbG)73HP`L`k(D!E;5S#nY8>L2soa&q|u)mWcVEZ*0> ztJ9khW{|driyifU%7>7%9z~s16Hxbd8WcSIPuaJ@_#9?x>a&keQmek8hQDZE+7+3} zNmZiz@4I)E6USqm4eLZM6-i1vX!~o4cF-zqPk`-#)a$)v5r6_SfYw#hf!w-2V75}2 z)zC?2HN3&HxqX=EeKd>+yws!J%nbQw2g^no0~}!n1mFn&gx=J4?1yLT+S5}ScHJa zhg46#*)FE%7PGT?emvbgqT{Z(dijb|{Gdel6xg=elqptxlgkE0$-mvpWnY?ea3GdR z3YIfL1_P61(r~f}K7#^LG95@N?N*d(PDcWCAZvl^& z*cnCYWh>oDKlB%t*UK$AIi_$^UnlGRS)hL)AE_cc&yaJG?z8X_KgppW$~vAG6~=pF|?PY|mBww>llK?A@{5X#V5Fi#&5Sg!7DzkSu*@gHu$ zNw(A~rSaerUoy7Ub(8}@0__u6XW(Ns0wcFQ`3Xs{iT?iqIezbSMZ`@`j`e+b!H$eFr60A&>mKeH=41= zjFN#sWL{Pm&aUseSaqHDwX8?aIBu6%2kA`-J$cwWc0|d9L~wE{YOt60l92H5iLv7` z>A}R<9|`nYzla0&IC2`SkR!_$LykPobB8Vb*bS3!0?lyk@QEdB3KVF}dD|%#ca>_j zJ7(vRDDmp`Y$(IJI5lxy5Qu)HN7oQGYp9;#ke2O9-F2V8&$%?}=R1hr^3y0r$>MQO z8dA5y9n94_Uy|mCQ5If?-dQu|^kAJi&=iNIb(e{hN1api6470N{-;6HZmqMPR2y!t7KPfPXn6AX7B9gZ}nJXWvPl=WA24(CNeQW(!JOv>hm1y0M5Iz-Ja{sTL8RBJ|}jQ z7s(r0bhwhAp?TOmv!#30?l}+;yJvZUyNQ&W+WeOEz+-;Y0_|2D?`-;yGu zEFHJE!NLDRiVSmkc8E(#paQ{e%p3WD%%MW&L~59%&)PFU!POkP(-9igKfbrFQ=YB0>33F)B?XH> z(azEUAEg`^I`Nco?zpPkNaOlS;o-70AW-LH8@csjqF^F|-{k=gJTpbm6QBv{XVUI! zQOGT3%jc0cLjhYfVaJ1nx$9?FdYUCuk;@#@H~_wIuV~Pp>E!yjeRSdMG~eqfqNvKR z%uKg7(dz9HrbTu-R{?QV^|5iFJW~AkB!vo8|I9mo z)?$hvVl+W?7wC`1r7azgOCq{C`0WGm?nt1H%X}crK!844 ztl25#fZKG_P7mHMJtJj2NGM_fAv3Av$4)4`0XTGv#LqK-Q{PgDpwm|X>U&gX&AIw# z4a|2BAQIuz7}bu9cm{fHz3n0x*1diR<`@^3XYF^`3O4bHMkD~T-d}KhxcV6I+ z_J05(X``rlAuZo_yb>+uy&FtDD_WdoOc^61uXXprb#qX-6aEN{MGKOdm4R>vWgde~ z&6;naBBDuwHsvlG`6DCc3}bQtDsm}CJpC`P-s}tiSk^vvD0tgxXmZR`$uShu6aAbz zP$~VMd_4{MM5=`>-DqyV^6d@S7gkXeocNo#`go%G1|)bJ9n!{suWmNBiP#ICG^E6* zfZCVRu%Z&P02?CT`JlYNmz(`TJxzM%wMV?j))L#fyua9uwZid03|=k{^nH3~3UA)X zDmG)$cImI*Q!Jo%B-ecg5V6rCP4uxa)tT&Yod`Yh_Yz89Rc9nDs==$rP(2>?D}iHE zR?Y%-tNsE+gyr1Wx9dyzw`mQGX!3L>*KCgoPMg z+-Pw7Ds-@MZhglSnF64FF9Tq%6HU#Y>qr0JA|Wa4ehVhdSdG<|bA61NS%W5y*j(g`ousOC|YY#FI3$l5}!x?^3=~Sr)NjAkTZ3imWIC zERl);8d3<^L_?f-2Hu9!0tA4pPj8c<-0D7)h+WZYX|W8z0Wp2&bhKdMk76@4)3$C6 z2pCb$)7}m!ack(A4{2-Q5$Y{}=3;m|pSbprk_wJ$z&b(nM+QbhmZAQgHxSKc8okdI zS}lVG$dIPOPmK_0e>{QY0QIh4*PFCxO^aQBS)nsOkl@*L`fZ-=_+-hcp+l1qv$H6k zABI$0xrFNAfHH>b>z|W&LF1`E%_#85T2D)41F?|$_d&|xB+G|{m-C_#Xiyl5P_Z9q zjQ$H0BKH3WD5PgI*PCxeX)?Wx9IEtxFBtM8c#@i)?uTuQsEK~X&<<`fn$<%p6z+>$2d%N-hny5|jKjgv*B{_=CGe4Dx{(D0f`y z0(6b-QKr5j`C+EuES@+l>R1r|&47-_i~UoY;Cvc zAD5!ok^7mhnAoxyhx&EdCSuJX6rq#YWq&6RtGZ&?DRCqBA~^k)&0%CqG{_3XJcj+r zPozPEdp}&xl|xbq3pq5u1|;=`+z8j>(>Ml(B(!E*Y)Glw%b9(|Si23IGwO}fezP)l z#$j>*Sr>X{w8@S!Zdr)ITZkiA46(6KzUM*y&n6|~mK&O6sQb7jY2*6rNOxJw8%qav7}=6H2YIg5Ox zy9AUgBZc~P1Wi*6=3jUbB^_ur88!(_C#J0yMd#YBVlX4byykRbNv1ffFecRrxQEqR zv9Jc>=;yRw{Qxs^YcXx|+5HDYz%lS`==kpoZtq>7uRk#-;7@n){3+^$!N0#+g7O!+ zB{_-b`BzEwxOcP#tQ!V~=UQl$2FmnaZ)j!JP3-cIP6=P7#*N!Q<<@m}X^aA>gysx5 zj6g8ys#tI6LAP)I+gwd^GgBnbQ91<}^*7Dp`GrVfU<%)#Fp4k{LulM-8TvPDWC)fp z)Pd0$F_cNoss+v@bZmMFHZ6X4X8793*S7)j$v#<@cA9Wy&rD9+d)-n;87OE6(+>(WM3H3hDM$^~>;7gejj!Ly1y>~Z3lCldeyzku> zxt3?!{WZwoGcbza0^Be}Qf;pxSIoUia27&(>#!TrD~ze&@z95ak)Ig=Z<6wy7{m<`BkUJH*^YHU zLw&Db2Smg3*Nw%LnCBGQ;h+aY785(1m2=TKESsaTJx!b6?=_qB1=9)rLeK5Tk*cuEKc-8m&A|}3s(S0H z{!;!lm2%%nFwbM&EU!-9r4oD|WSKsDp%8I2bt>K9Ii4}c|EAUN)sgeDdYwR;%G0}Y zC8|bEmJZM22222gqZuGLVCCnbmH?(AP|zIfiI-t<8Zv|%$pX82idC*x#>??Y-8(B# zIThN?{dlO=_Mo00x8 zP&{`uUxors0V#Tv+qnLxA@EVmBBT+_7viouPSOA%K-_t&Ks ztY!J=_>hMcbc2So&_CJ}&FE)k_})IM=1L1KXF1#(^we1ZZ=Fe;SYB1bdjTisEZ8zn zlD<-5NM8lY#}!Q(qY*;`X8IfhxY=(dLjw_d_^So9P1+}drZM+2E-?Xi@hyvKFFLyw z(wfk9{AsyixzvD*J~Fg(MtV)M@6`N~hA0oPyti#HlBi379Q)U&PkFR|P(J zb$bE-g0F~itFsPq!nZX&c8{A zbID4v#$7L@wcqlQuio&I)S)WO{jefEYASD9p76!9mwZF(6al?9)&qBQCF0n(@&~-0 zE%c=4%seh#HEFeNb)k}`C0qh*Ed7s6%KlquM6sf}_t3M#vjxouDw^z$b{CI*A_Ps9 z9{nzpF;;(wR)Vv#As{+yeu_TMy`ZmBnU8+~C25U70*%3mXGSt=8uaW@fej;J;7ep! zL>vC2poId9^l-xUPLgUYv0hRyy4udx7$sT7@yKeU2rj9RpJY-5oA32{kwS_@=CZ;7 zQUtXDQPXSfl-`>(vfS)9szku3BhnY64XvTZX-^(?>+_Ip`I>QaBE?bC#X`9RWd*X& z28q;tLWxe$#i6vzAO!p?4g_A{*^o-nt~1_Iem1j+4F;J)-NweuZGEP+VD9J!Ob;OQudqq?A2pX_t#x(=AqN2ypGWq!0At> z>dI5j05Jlal!LJLjIM5Wu|gF?{)bs>wC9#F6j(8*psO$c7T z<44VBD#Ajp#<@eiNu#Y1e>*7?keG!|Ws6r14Nqsl{#5*5E}cmIb%NyhzITM}jqCOX z2)*p9*x3$C5>RTuHKSoy=BI3zrqxecKjzwWRSMyogAhGAWu3~GwKLXoAX_+xMp2)K zIEJYw1uLmk`XXbX8Xhn+^&o+#3bLOvsAdND9jl~>;yBR20ZLrLl7tR6t#pZG*qf7% z>XZ26|H}FWvNyiqmi^_&WK8Kx0yaOluuJ)}4jdY#vx|*vYVSrc4qzk+Xz$hl2U$)i*?6D}k z9>$W&X#;W8cYWwY%&583xO$Co`MLqt=-{^Ay?nKvdfs~1Tj}y{ID*@dR{EVDs}#V$ zZmHs<$=|4HY_@&Q6&G*XCD*$c;T^|UU=Z8Dt$kobI+hkh8( z1QAnrkrCu_v61_{c+`Qx4wM{V*(4()V=^=R0o77n5Ax@(YeiN_9tAu$QmAWC5D9Pe zw{hMZ@lQGdFwPeglF|T&{?1Hh6B;>-cY{w8QJ!v}Aav8YS!fWB0B9%jSvl9swS#SE zRpe|46zyckTvN)a%{$)NpE84~*E^L>Z7@w1PhRCzj_eR4D)3w&9r=O^SMY=U=L`G~ zwrOQKIqu6D2;lGwJ3jv_mQk{M+>laD(b7+Ji5UFfyouYcvQG$H4T_O;#&#;ng>dB(CqjL$u*#|L;Oy<5KNqkuu>FS z&(15OCPlA&iPdd7H4W|9L|@29c3}MnQfH4RX0rdKB=ZKNj4iPsc1+}hbqp{~E?ZHF z(S}<~@O;?*fu*gpUxwo)Y0r(@DsGP6rCaV%U1wF%KX#lv);ujg@X`3>sUtC|p|XxZ zzDjVtiCy4{y~Lqg(CT?Zr46kThbLyUc4StiDDo!RmVf^GbM}q?3H!&&t)*Rj#>c+v zW?!dhk$_)*;?BbZEr3C}`O@W6qRL$U)5$=1)q@p@g}-1%;MS2NZ6hLR#1k`X`?P>U z4htm;eCU5BF9b+#5lt;l?0!&nCjY}TYcw$I1k9$OGm7>X7cYDsz096QCa^>(1eV47 zkP0L_{VYL%be6%J@y8r=^GF#n+T#1`k-0OSgxYy*=mT<1pCuJazAPa}O%(*i7vj79 zCZHizjI1$R`cVSK|_Wrm*3?1HaVLnz`EfMc2@av zUn(j4$d>t?S!o@}1sTd|gIxjNPI|~E)&=K^;JVMV-SA)d+y34hg3=fYgO-wz0|$n@ z!9s1%$0+vqO$Kmj-`}>&vQe7>RQr3iMd!8;cAaKMbtJ@v@C$D{~pE4C>#_@+?JZNH=IdZ}yDEIfj^K`k2v4*15Iyg5Yup+}+2f!TZPm z9)dz8xZ|^g9lQEh2uhGMR|jEt%vrKDuuz&i5nwDw(Z#2)#+h`2JA$wW5NM|khvLCkpBpkVqxU-9m0!2EiilZFJEV0PwJh6#Gk)7}Pg@B*YRSxJ$5N);A zKq6J4FIbz*0(NEaZI0FfU;Qg8gPUXn{{P1_PH*Ht=~d+FT}qmq{qJX-D+d4f%s72R zgNSCqEDy$_*_CIZgD>kMze~GMm;$7xG`y|DzH$CBrZe-<8xZ9MRT>;)|Fwe8 z$FG;6D}+z7hQTEco}<+Syq)6<*2dj*U;1_;s~B5XN$E2hf+g-8OXAAcnr?M+o^rWc z?DTMt4j%O{I=DvNkV|$Hx)~4RTOe3CXe-(k^pnF+D03&EO<%UJ>8d&N6FescU!UIY zq-|$k5MFg;z-q*DV_-)h;iSI;%QOTtTk*;||Iy^S{lM)9FvInktQ{~cq4RE)3|2ei zv*J-ZWHM!zLX1o8O+YyCW?I0=rF-q8_0x~rqj+S(Ew@ES+P}CF#=0R3%c%`LYsJQE zg5mWG^M?Mp{U(nz?*0R?Xa1{p2_4^LWULl%^be@YlXKJNq#qi3%FVp(M@WX5>^pTR zG%@t*NV}EO+ea%rrapPQW76=7`|Ck##8OG)PeBR}E)W~D&cK}|M|u3$unHs#?6>ZP z1fQmKKdT?}bMC}}?}vwYl7j&u?Z@rdp}e`^;@7d3^S7FN~KlPbCD z>zPVi6lbCT8AJ>~qx6>m2Pf+`Z|74{5Ww>-24!I(m;S8{cV8=Et7@T76+5?TJk8nr zzsxWE-u~r2dH= z2lj}q!2hyTC@w>%S#|eTggq>}k zOB>IX zG?$dQ001Bx82|(}V3wmW4lbR0hOKr5000<`1OPzI`P4lCV2SSi_TIb&z9XZb+WZL2 zS;5E+wM?v$NNwhfJtC$>{|9h-ue^m}ZLX*3#DO0GX_Dd(2vigVkjA;JWuml|O)~7g z_j!p0e7DTGf5!l&XD-F~?_z+IO3~N&`&&;I(|MOuTWxueYZFf}WA@AH;$sylw|`W( zbtEsG1;`!>s5o$pcIBIjj)#Z$A$rgI^q7m0`h@OvlA-Uje772UfLF9i$(SLtfUN() z0_tCJ$2pq?utvvRa9Ki#CM0u~JYoj!N+D(Y8`)e*eWoYPtEFPM0#h-^omgRKk&oHM z*5^#p(1zQMv!wIOw+1<0%OoDHne!o$K%8?Sr+c|UUPRC=RoisExNH-Ryz2Kptnp&GDui0IRa$fvCCLt zaxbi%vi@f`O6r6bbR|3b0&E%(K>oGzqACxdelA^@w{F|YWUb6NLT?-Bb#Q(gA|mIE zD9QZ;gl27kW2W2DFb;Cqh{?j|r1<|aY=mb4S74R|QX;c}T;WM}9b_-mW}?)8%^Cqp zG+a@^E!KXR%fUs*7HXxeQz>$MD{G{u_)awBOr7yq>GNZ|?8wsW5b-_znl}DxvVw+F zCeVX}t8S7LUB_YUKuBxB?vn%|{G615{8%~B1ovkgu(k6(37{hcL4~zhF0pN~1ITEt z9SGxH6EzVlE`%Ft*1PH32dB7?&ZKu^H3zV;c_FoehV2g7(%`dNOm?$uwa)p?uE@J4 z-D%@d2a-ysTw(T{|M%?+O$6j0o9x7Ly57}wO?oVeQc@JCiC!`^YwaXpl^F$W1KEy> zDu{unuf&$xX$4G{?n`{U7$~ z4TcObQ(|xfS~-I)5?JTS*-}Aehq#H0rs&(e=1*ruX*?dVk-aeFotWfNL&mxe5^#BI zhEODhMg=a<^Az%C^cOnf=hmo1Zm!9zzl-h#-f)=*U5Et+aWVB$MZVfnfdyQYZ)-xzZ0ac>rC4-M|D8c(;O$G-NztK?n;Z{ z{q&E^SLz%N);9$PH}8*4Tb^RKefYAX#e88k4a!%deey?(#6fkP)`X5MAEOSSu$D$4*lD^x1P3aoSEa8FwQjuFl{Oq6F4RNTklQ z(!?#-cdjt0A=h|5ykY!&}lcem1TnLymnhQJ49qng#SED;U&9-$-(Z zr}OTh-v1d4hc_GXf;qyTFnu1b#y|rQI1I! zMVGj^T1>7id_6mYxCT<$Ae|u8B?#;_*5Qr|PY`p@@6GoBcI{jyAqZh8kLf579>S-_ z#i0a!G=wK7aQM?BqJCQ250<=gfPo#he-0^*uo4N1ZDu9Y5PS1Cm{z9=kqZvn^(IE} zj3m7TG&W2A{hwup&{RO(O;PUfuMlHQnaxj`ofYxejNGty)4_ko6XRN7&lWFlBS?sG zFWE)Gl90WyNhPyf8*FB!%Ryq+J^Rn9LgxdCfqDvT(tBTdrDR$b6XUC~)T8F)w5={^ zyJr$dh^xu~$Aa9$vD7p{+{}{U7TaNhnZGX)pERlKB(x6sp0|xS#1(ufNcT;qo9nmw z+WI@|5o@ols3S+#c1RN?a7WPy6NuOn1EXC#XAIv7i7<2vK(IsPjT2@Hz_r!yWiunC zA)d&i`Mcdbr3Rm!Y!>Z;uV6Zs@K_WZB`E}bJI#=19{A25_!x}+TT}>y;4ERMuyJg1 z^m>)Hj>|@5=!EvsFZDhKqrla`(ZPGF_goIq1BgHTOal)IG5u=^d{VI7#tET{D%^x z3$<|U2WzQ-=-p1yA@ta0j;(8UT9iXN#fPGtiU_6OCzp}} zW&JP~weACmH%6Zi6!cwbl^et#ln~rshCvE!kN5p?k~ieuwisJ{7Zmn9ylWiU3(eXh z*<(L%sg*F`0W)+T)hplfmt~MStG^XSU1tbBc1j+M)q7N=pevf*bj&Z73kC(cv@C->7|IrEFxH29Rs z6WRngfrzM|(&fY0e(4`hY06lqG}b{HRgYqtftv?34y?&LE7s)Q!F^GdJ8u>+c^`*; z#?&IExc86TH#-3i>LaZBXZ^1g_CwBbD z@7sAbB0r)5El7@kO#bIhX!+nuv0{HC2`3?pXhst7o;Pz+($lrse&j}StEyJ&5QES> z+D$??Tb>VClbquWSi11T%v}K&aHs%TIy8a+9Y_Pf3%LRPd<~Hs{i~TU(uJFM*GVi1 zK1X1wjUrP41|{qOs?jckvj*DKJBna_i00kZeOt6N+Y*m;C+SUX?%X#6caHq&&2?48 zYDC{dOAt52bh&w_f}^QEb?x};z?%n|v!S_5g|GX-e^A6%}aC!62{D2@ODj?XO~sKKhSSu%-oSYm1XLQ4yO@_fz{mJ*7~nF;TL z77qD?EJDksOqWe1Z-I=^ICD>(F$k-)z>JC2%vD!z^0EkMa_wpg{Jd2SR2K#dgn`lT z)A`^etL<~=dh1u{smV2giaV^xw{>g%nmC{)**4O^dG{JK;Mq5=L%UTvSDL|CmTZgg zhdYAlbWS$NnhXIPh2Q<^rz)GD2*DO5G}+@YtVC19^+;e{6i7AtKG8+>85YGlZhl)^`{W0hAHTz)#Sag--RhM{cZ+ z(9x#@jNNM5Kz@rT>z@UfaFVad;SUQ*K&*@}Td%t_0LGk4D z<4Mi7pCylnw5N?fOSr()+=kfUTl&xRThu&#H5c9hJdq&nd@N5S!Nf&YqArcyK^&Vw z+H-zYd%ZKSP}9}nkEP~ecOl%_07E1rFp1~GyM{xC2pj>6)>-3{%?@$Don(M3JJ|C8R-CneRDl^&hL8$L2Sod$v@$^& zaQn|?7jF?|&Y2nqNk^s_@kT=2mm6}sw`$q>x>K!Z{;TwZwpU+j4n`B$w3r1tj_si6 zL#}mpc$-x~x7#WCa2D z@X|(82aksQbz`Tg5XuA~rT%iE=?jGA{=cLjgYR|R_%c>?ZL^9w)n_oBGVCD6Lj2o2 zo8;a6fNTgI&xbrYzG%3%V`CYCIv#3^#}A~Q>9Ulo-cawGeHQbk`U`ze+m^RfBDYzd z8M}$8r&GE`YK<0VhURx{h(FKrk2#QG)M=SWlsTr=ZS!VL z+$ir*ukG8wiHKIx&KPv?xZMLdMipw$ov}hwMveJ5&c2V7) zyW+{m?$-g+M74_kgH_Uk+$${pfqjFPPta7k%j52@f{s#k>b=gdYn1E^<8}kpKXAvR z3DncME6#rGwhqWd=VVY_s8o{Bxe*qUpOl~9f&4j!V<^$mdv*P1_iCVZVENYf40FP5 z%ak>d)olp0nX&lcyPm@#WDS2blent`s4Pa;5kj}EN#NhmsC4UZ<@5`nm>=dTD%>lI(fgQfsfNL)xEb9UgvWb% zF<*94c4IRgM5hFMk9|U2#ZIlF<=wIv7CnNg0m%aug^M7Sa`Fr64O}QHFnQOd@sRYf zb@>lAH7-ze3-CTFAt*i4ThY+aIB)zd2!N>aOuj>5cjwX9?%#vlmsfoipX|z_M|<=^ zPh5DZ9FtvRK$XMYU)P*nZ)0&H|M(C;KDF;pju&ulKG?F3W^!vC(lQIl@DqrRc?C>| z)_Dv0!{lmw>g80c+(>dRTeBqZby%q)TqiCSb)a3l9l*H$3oV~NUyRcLE?3#n<&x$R zq?Q!^V@zLfrD2W+wqX=J)G!)IF(uIp0P(tIFmsV)3c1Ur4T^24{t4lE;nrPuu)7^3 zbvE*+h&9VP7P~40YWb zZhsmJPzVCIIB!-kP}_9dTQ=6?x7 z8eY6*W-L7#Os6kxTK|K;8Zy+ujl7c(j_n}wtIgBJ=`*Wz2KC1p2XYSXPCH>q0`=&(N1F>zR8qj~9OT!1yGziMITM*=j>P>9+zfTb0wEJjdEO0Tq?N-b~&1 zNNV-1KU{6-=3A2B#$BnX?fY&L3gDNbn)xT5$DTY}GOm6?4hf9aw8{&r{Wtb1D&zk@ z>{Z=NzeX^f{<)3jBFU`j){5~sK~h%0%E&OSW%B^LD!M`T9%0#hN4sLySd;bGLHl>%8iShV0#nXFcwg_i#C5E#Gue@hk;koezZA&<;f zhQG{(s)34k0X~Y5MvFqSO+-gS875)C!gsK`Vw?Dd{t+Ibe*7r? zVCMp7ltY&FJ5K#HnYrH?-!2_}%roF)tiW5oy>FEY(tsJqc$qo^k*gHbvqCOI?lwD~ zo1Mnozr|-A1p)Xkh8y1pozwWuKe^v%MeZa$Ma)3eQI&*Ay%qOf0 zh4CQ=dVn5kApJDUOArY8IV=i56&!=Winzmbx#P?((582jz-X?N4Ic`e(GleB{;`MH ze(RPs>vj78v5mQ2s*bkNY#Tfiy})>Z*rsj1c9Otg0GEamFy^v1iy~TC<0EhC_ba_R zDvg7BZ^9?2tH7(FXvusdFY4NP)SU1`4!5y`@uWP%U7{F}O!q<;HUpFyk@Uw#%QsH@vJ{*y6ef zq@8a`X`pf@qW-v}4&I-RIvSF!eGdi!{Kynvnp9jB{YFAC^q}DgV1A7OJXC83i1M9E zpG!1pe-%&y&r=)Ngx+UbUVTF6fE06vK-7O{4$Z}mkv|BSD(o-n*!NVpJYV?|8&;MS_tyXU17lu5?*!V@JJlp>0;8JSn*G%*87?AII&)nl zd-K9PJtCzzA;b1L=<(N#V6~u@8>`DOAOzesIyNqE$Juh~d*rH2XO~pUpMA_6^0w-nJ13^2x1ul94S^XLQ%Y za~rP4>}deM02;uKTirI%)>c)vs@YRZtyF#_fO}4Em%j6<-M#`f3H8z}+em@4A^u<^E4Mors=s_w77=1Sw-IpHz;4QpXZ$uwgTP6~6<2*u=jHR=hx-`m z;TJbKw^W*J!Tg!?tC)B%<`j`IIdl*iD+g~>CG!Rdd{dMWBq&36MD?faVLJv!XP3XH z#MZKGMgdj_;Myog6Af&5T%|sy04080Rk}r@kvlKxeRGa)t@0Y_S5ddKCOW;&9m1FTutQ9*;MB2>5`_43Ji3d7N%`*B#{?4SYE-tu>hXE>;c2CG@$xx5ztHkcp-A5jggkf8<^}C zwWTb_TiIr4G?F!z3^4CWOMs8SVY~PU1E%oBs$tl(!$M0E=;4Tte`fOqWMS%E^#e}q z&AacH=1i({U5Y6(6fpTbhkU0VWr_5Uta!NwRz2n^)x7gqPe51i^m2aHW`8LR>?8;S zJJDICJLX5FG3xL@cW{)Ay_idHDUuCT{(IjAjXgui{%_Gew0Q#rYWZye#Tn+WDzBvh z{)XG07$dZQ8!BXMz@6zNQ*@d>`R;}Gu(tut>$e2>d|u}WfErKk)xBE;q+ERg#h@n` zvj~V_@`?YTB*88M6sTvb75ausLP$8Qn+T!HhC1*{`%7fc8S;85A1mb9wkY-+d_Xpt z-i+$TO!NRvO|JfS7C6Gvm#YM5YVJTjV0coi6l57Ua-2{dTQz?20Y%Zg8GG($CXV4D zKwGn>R^|3z+M16|-_i=2gZB`DyC(O}&ptoU4}`FKSAo;Ou#J?v)8VVGOw0@@Gn=() zza`SDuQ|CL)#?EIuiTgC6$-uR0QlsrYv{J_?O>%o7u`#of3vWA)|%y80Jp+7!*%58 zcgi=9GyAj}$F4F1%sw6?_9rsf`w5@pQ-S;KVaf$EzzCsHP0ZuvT}<%bi_Kc|G+&f4 zhdXwO?se|*Iqo-wGysx8c8mo=r!uXR;f$pzQ+?4KV4;?gent8KcLJmEu4Dq*pNpFq zxeDg~Zy#S*1I%$A!#D1`If2#Lu6y*Jy61v>W8SR!%*!+EU^|S%CEHHfkcmw9*+HpH+Lv~&!Op}>&#M)vf^>XVJ>?T%QVUMMyL@iG-y@qa zng{|`IKA3zY3ko?0kTOEW6kB7HlS>{H}oe4v!Yfq2e>9_-EiI7Iz_y$Vj0CtfD?jY zEZt`G40L#K@V#ARmjnYbp?aNX{1y-OpNZdM(WaBm^ql7=?KKk(qzow(nenK;0_aR`|5wSffhE+C6E1ED(P# zItm#1{~@esoG4gQ(=2X|363@;?AnEiW*t7N=Kc*nFy|l(3w&P3k)qqujB>6>`xiQnAOk4Ksch z+Vn?%T~+5Mi#IvM!a|cCe0F>7R$h#+XmxudM?7l?>uUp;ad80JY;}Jk=B7r3^V(i@ zCGH1u-6#cbnG`&kC^ikaP-JagJsNRXg^;LT;#Qfpmw%f+&!c`2h&^9w2~u9E<2eNS=j(w~;%F40L_5Jqc%xFGYQiN+T6EJUF1K{&@{P&T51I(lCU>Ox~uZv4BU`-ZO z@G~w%2WST!O!+0J+XkNJ!0+XjiQmG$ z2P{udgV702Xr9%@dz!gmx^oi|FB+1m@?#n+`rC`5+Dsfpn>CYH^}B@k_OfSrzizKj zpL>r)`98tic^^FCpG}wr&Tl)-IDK*JmKS@7-MTGlG8&(36k&d?gvzG+!;Hq-Ez8$W zq8a5|%i%AGF0Km6w9jg%%05t2xY(=^S1Cq`sp{J-8eMEiVFDglz;KiU&DV<(d3Z6# zTELG*O+@E*^o9=b?9t1_aj!zf?l@65i8r)Ee#rbNPXJjJya8lz;IyW9yEMBx~Z05$mV0Yi_1Lx9hee&dq>bKlAc=`@ITfz>x)Y`;{;^x;Cfpdog#ZlJZH4<~! zDt4G&)nzx~?d|ZXbX-vzN94Yke54;-Ce}-meU6lKnZKHv!&@d2^`8ZM%;mFLTZmfX zpZQ#(#%CJp`_vU8&!eEe>VEvIv$LevJP#>Q8~Cx2J6b?k{k&5Kln*V49Hdd$A335-V}5X9tyw!Z1Np&U$=0!+`0|(ig0jm73 zWDkEqMkLd5vInsHpR}+VV63g7Z2`C*8Oq!av(`wgz-1xvdl_K(Vy#mx;bN!TtQHA) zDqzS--R8!-_5yC#kPjL&Z|!rUQ@eKvUsHK0B8v~SGtFedpw~a{|GrEan{frOU73F9 zQ`}aNHI^vgbRQP;Vtk5N=2v3O9^h4NRnxKK*$KAZu@n$^3TJJ3r1d zDF!uqPh5D7NVp&`Dv!I;GGE&>^60JU)q{AM;)}HVFiuBRylRa>o5&p)j2Jbx7=qGw zH3w!kEA|B;>`8rH%O5QcSmqGG<#BH294$(z7TL9aL&Qtq-f)7MlZg<(`$(jh2Y4T# zKY1UupNC(?LP0CR+6l~MfL`!>c04J7?ie0nvObEXL#{x*0$E!AS>rB8eS0J(?S9p1 z2b_%H&yxX|>N){1e4@w)k-v6lPxJGoHlU|FtX2UqiRmskF2&g!ml@i%LVBJ>qHZDO zZp!u}`9)vQ0Qh7w{fbT3_Vj!K7g&9?sg_%LbMKqHVPgbF>XA(m;6$O~eu)0)?ffCd z-xcfckEe11+s+)JOk;s1Zt8>4pVWHh2P|>PaTNk@`m= zCtSn4Y|joXD<=i$w}g*@_fCey8AWi&J{PP{JJ&PpuY+HDI)jFFUa~rD73myue|UB7g!wR1DMqGH{54T=s$}rxk)JCYK6DlbFz1{2Vsq0 zP|hX2k@w;kNTks6;ETDqLwp-_%IBU2DrM5~PZh>=K9Y)jI)5XpH!Noy0+L0R?_Q?s z24@|9(W(u^@cX*0ibZCjeWL=N0_6g70|<#HYp5_|o#~sSZ*J)}C(iw>vG)axONiXf zm5HIB`u^<_cBLtiEC#`Qfz5qhPBjt9x%ss9JgcsFX%Yp{;uQLwbv_k8KWI|e8Do< z5@1Leeyi`nC^wWY_`kYotNyYlrkbp_t(I&bQ{KSHmSp`_xK#Y7!{aF^ww*mg^}rTihXC7VCMIdP9o{%0b9L!IboSqc_x2qH*UB* zSMn3bs5cS<_qNLRob)QMolUKDYSL@nO6=C#yD~yEFm!fy`9?jA7YyPYFYkD2;TQ>ra?-=L*{!H%$lOp=&z>}l*M0D|p) zvKnCh(h>eo<;FZu{kZCLRBDS>o-ZXR(nMZcSHv_kwaH}nR7}Zpsusb_(Z?Ch+y7Ov zp|U-H9@6{7`D4LXUaXqcjDbT+vShk-F&RK`0M;*gu`%y4H#u)}pA@|GeLOq~B#XH+ zSfwuJxPPEJfa5r^$9?(pIF>Aj9}9tiEesXdQ$Po>g=rqx9*>4fb(Sr!A0=@j@114> zR$lN0_HI-L01;=$JIa!Z^Jmzdi^-&f}#Kn3~L=_Y&|Sum_fkDoVV}o(y~WA z!FaonEdZGx#u_QrcDX{hyjf1%)3 zne1W|LjQnx>i7z1*@9|C0jriKxx6n;VtPZmVa&)kh>&o9z}zKAPQ8p~EwHznz;h%$ zi7lYvS--GKq#>%xIV*7u5wppv2)zOhp!D@m^^_m)_`%@`iC@`@ha zmDm+J;}v^?Iu;Khtp%h7ySCw%^BA=x*1lTrjHd|OZKnE`>hvG~_yj{u_Z7@11YU4F z+Ux+I@G-fp`ndbyQX6FFcQM}(fuzLOmxXdJ;{J-tdT#&^z&)n1(qk>@(kl;lK*lg% zC9SM971~!H0P0$}0M1UZRz*d{iZQq0JO{({5h2~k|D+%POx~^I>2`e!Pg!acG|#D& zGb&U#Zhg}`uZ5TpsDEkl;nZw=p4ch=QP^E`3RM;!O{@_12bc_Ta)%f3$}N1y{w=hu z{HwZ@3c)!m+>3`o-iB{QDcu;OAcb}hPMC|v#MBiYNw z<|@E++0L!36VM-3otahuwn1JH^CUYp8`jqt-EtG~j+1}B0|4I@Q$5{{fm;(dhXll= zDRXb_I>{R;=xqp{-rIL{0z=uyJQo9@gSt}dm2*y9Oz430({X)BLfAR}sV?ZD0n-LCkWc^OvTQ#8_VoHN`-j{Z z#$~mSF*A$1{X%?pk2nPEP&Wp2x+d$4gT?}tW><6qile%%ZyP=?H`*`d1!?ee> zQf)v_9VwvSXSRh1OmbD&U<*4-#|l!W5a!~@w=4FSYV1o~&x%v4v_GIBc4YW4HvYvH zk#FA?aqxfIB3kU(A~G=lFI&W^eOtuH|6z;xKL~imcrwhSr7NW3P89K;gl`V@)Z{qT zB!S&E2DvT%uB_WiMtNgCHgCnjk3ghO8GdFI(_nhRGa*l~+zO1DO%nxw(}HJYrb5Q&*&*ujfF6>)Zm!*VFz?k;_K~KU%4QLYxD@)hV2`CWdGCM5{jB4^BmT*wNBq>3&-1xaC_6{rwVIfZ33iw zOJ80MWfXzmF%>kUlLkoTM{36>iiQu%j~g1AN@`^<>-l=1_(+GfuCSxamcDc)1U}B% z?${4?Zk)dNwwzkdFd?5P$|P20B)>0X5D(subC5{o&1;*lsKM{@>|7N;3;3!Hk_A26 zbCw^u@yd!H?oBz(73x z)K+(Tuip=tXXKo!Y6{^vG#kk#XJ{l=Z+P1OBXwZ*kgn2|S{dTR=>Pm!n0|}Qe8PjW zo={ZlJR4^LN46UE5o6OT3>ID*-4t)I!25jwSO*sK(^ROBB537wMMZO|{pR;a+efD- z!vXYtTz`N_XL--eZpbOs@`gQ%Tlx-s>r=&_kFNrpzS_^Y<^VZFRez?Lr}*ttIcGGH z7nfvk-90LM9J0PhdvqV-1yb2@=?8v-0Fzoxz@#?&z@+wTxs%CY4`j_{!-~GsOpS4t zRyLNI1~}1IOWY;Ib#LgDbSIVp?OfN zl|h#$T}SRkU8Fc=9n81;@L&HjF){d+%AKoF*dTrsL)mv%5jO9FcGK5v&-lW8qP8!} zrInSwp2U=rzJCJj@^T)AQ6S1Z#=a+rH2?a9auc=tb3*1DwJS{1dk1V0oE-Ulz{2I>=u7M z1s=ytqsfU;cwna5mq9#2U^rpjs#hBF=R0;M*BSyMwx2fFeq4rjyNb!bd1;#AKr7CY4B>sVJ!#a*_D)B~IJtlGSNaPhs>o~+Ie8T0r;f7%j{nuXwnIQ2Uz#EZy}-z{i#pSZoaKV9VL%7Aa1SuTiX&H( z&Aje4q-D-W!uQK);@aJU+5vvi54|3|7;>fE=iAQCe+n|~eo|d)5Fo?A`E6PCa*X&!_(2}gE4~Gc7Rj9=9g;*tizyqM< zu=)$iIrn)OsruDR>K(fX1D~VOce%%VLwb{S+k>4|$rZyy7bam^FOW=jw#H8w_88yp z*5WABn>DHf#vDM5W-C_graUaaE9aceiE%VNidE0EKyC2C;X;snu>$9mM^#{Dnz8M9`v#Z$f4Ep(gN=stpFYt znqPTY-(M%1ICf1|$Ex_9#i)LsT7SdEig&WLFObqr|I%zp?K;JFSUH%*OK71jFJ6EK z+Do%n|2&})YnkI)HKyDzzqX-mr>v?bdezUB%75g7rqT%o-0rhW@J>7v_bxQ@O%b6S z02ezjEVpzS^<~;QTT*k)`(_TQ8SWYku^;~_N6i_cOsdm->mWh3kDz9tD`UF7p0{s9n z)TuwyZGalho4ZKI4KDx$Pnh7m00igI|5L#kE;y;tp!cgKXPq}*h95;+PG_G|pfb-# zP0y$w^BM=Cque0<`0H6$-rXk>=m5)IVuTM6}%&l^$|kgpT*?*2=nNPHIMzi z$$uUg^x7X7Wc}|0gW>B>1r9iS+07W}eMHZPczw(`dfmU?=rgl|nL+-HU7{v(63E4IJRJwE6@%=&wb`HC6q zJnVys0*2&FdCHa|#g73@Gp}Enyl4UbnnG}_T-vHZej7YVaWtP_nj!}4w=zugLc?(`LSn%PJ@bds)1 zrr)1>oWCQnxmj~a3@-{^At7KI%Kbp9RE`$Q_`edJDbo?k zvg2p#+26G5V8R1-=Fxb*a;swcaHGXj(2g!H$@71wm;_Iguw$YVCCNg5jdF8kIG0oX z)rE4&HU^@Ol-_Kd1z2=Fs3R7gNcc{-OMJJ&;x+k{rD-24+s2HWm}VKKk8JB-I{bp! z`GRxChaD`E61=5Vrl@{Ym&h|L=N)Nsxy6)tY+U)V z%h~tKE+uxEH)r3zBux@f_4nIb2`FNR$sFK%XX+yvmC!}uL_>DAjE5^h?EU8t?-g>g zzNa8c46r<~pU-fxoE(y*JY-ah*>QxS9GXE$z$cc z*Ig~_BG8p75OI|9zJGcacWYI9Q~L3dn8v8dH)LJqM$oZAZd^q4h1!jUzM?nZ352vd zksn1cWt+BThxDKgGxpwwzf?OQ9dK~dcQkM? zSeEhNV5~m`MPBn6q`Fv8lrq%%zM`?YZzGPfMcBXzF6{!23KnKMbEesKvp|8gJ&w&ZTZ@+iF-|y7x_Do^Y|M(6~_WTIQ zVH$F;Yh|wPL>%;4XAJG>!xkbZt`93^hJTwuEYQbW&*?O(CYr$oCZ`wgtt($2QOXDvs+8r`rNcCFkY%zH zzN&pJrQOOi#~YlE&-Pq4nVHLRMQqXLD1H-H`ZZq>eT@n&00|f{Rf5PQF9Xbni!GKlr`AXc#!G{F*?H;~E>iom<4d zgEw4{@Qz!CR9)Y&e!%c7s0vBb)g7p)ng@8RV6Y}U`tH#?kbZqT>x;2>+-%b`=BD94 z`!<#Soxe%twGK<_>`bJsYtP-mdG}BQaugqoJDfqSk=vI4$f6~QNv*#Q3=`%Feb10% zeC<0nix6NXJH9d1qw}n`T^rC`b7JFV`CByVvT*kV>eS_t{@;(+si7nc8)W3iO;~Ud zYQ^`a9u+}ojXYnfl*re0|B{=xRe!iwKj>*fm$=k4NnY@sn=Y!H1~OFDfB%K>&a{pb zc$0Zi&YV=zh+|cpOji1Z1fGA?Lq2LZdRV!MbzX?GOH-y+5u7SD0O~=H#xMSeM1!{d zBBQSnL))z1wgL5u!oSul+)sv1V(Jy9PrBxgYA?m*FAHmt(>jWeG%mvmsP_Ot>5m;i z@U}dcH79A6CwA#awLJhB5ZkLVI-+CKF9sn|An-|pAMdMIAW!T@M=%gPVt&qI3x<4$ zYT&IB96ooJs7c+B7$MjIevnF52}KD}advA)dK$qX)*9YCiAYnwzApl5(6F55M9*5#} zCGxsqY3H|$FODiOymbyM$W5NVzOcJYl03#aHn{HyuIGGQR?Bn4# z9ezU=1w(eTK5%7n zi`ZuUov{*{0j?ty1SDa5ExH7~6X>?Py)^8$UA(oef!^J9>z->9PZ-9Nu}4Pc-2VZ~ zvwT=Ly^-}OldC(@fQL!}xYW?$$1dt=S1$+`c#f)^OvfAX(NNlv-!=RN2Q5(=5A?)K z2zD1rGk;_ZKu~^ZuI&PD0|e+LdJeK%+mSlp+15`(sLGZeFnU2t>6`+w(Yqy)En_OY z!1|X?5q|54#eo46+l!+;J$*AA0&GMv6sw#Zx&(6PTz>XBJZ48RX&?xmV#%?|CH6ml z{!Qk=Us{n0q}1gl#gsk=ln(IUQfga*^FO8lL5Q(JmM~Ul1gJL({-)kg)MqOv0>B>` zdCCJ1_XQzH#lHzcpaC?u;ksxgUOxIK`6+6F@#uwlqETEz^^@I~mg+}X zPVV}c?NH+!W#)#^e`n^%zh>sF8t9BQIf4b^_n_cT6dV1w%4=n;6F7KVKHR%>X)&e#g@Xf|M$h#PC!J zhi2h;rpm21jPJYHRH>QpM(c(AFYl%h&#e~_j}B^6t3NiQnjq2{Bn9&=UKtO|BP)}$ zDG+|A;1^kI?^&2a2xeNmJhnRMXq8OV-HaDn&i8>oEc~$&H(*--cz5ub@m6d(+LWf5 zu{|2YOUX_I`z>CZ9+nO;w|=kg^CbDjLP#}`!f^Y>44oWSh?{xUHmr~|LxTNDlCeJt zZ#}HPBQBJt%@DlKrE^MmGD<`W?rxseYLhZ;p4PtR3+Q3IvO4OgyFGR(CQD7vv^@)& z&Mk84U;{Kz&GE^giaOTtGAh-A)%a$c?yvQ1(JLq{>cs^3Wo*B?i8(Mg8WD{#UtGOl6Z;6vRlo@g zX~`Jh;jL?73~^GdS*@Qm^H8@mgEuk8s?=_QKK7eX@sL@rIcZ(bSWmrii3jPz)XLbr zQ06dcJ;#N{&+ad_6;TqbSGm>B*gc4$ZVV+V$QR%v8di~_D%`34)Y**rP1+?wY2cfeu*QTFq~L<~JRs(4wn-0&5w?+uzS{qy8WC z7@*MupPu4p#Y_6--TY-+_4e!i6T77UhZ9S5EzsnYkwgnRQ?_2vbU2}~Q$JR)B1P+} z5u(dKFU6bxmoKAi-^=hzg>;H&S^#rd&Fl9sD>PnWq18;wUctQ|*S=bTvz*b*>DLCx z0=gQn>}ikpv-H#;9p*aoA6#cA_0Cjh$F@NlLUlGX%5fs?!OOtSOE?zB@pBx#xdCxS zN5j#=b>G71F&Yg12Wobub8;9bYCTQ!-4K zGPrP!A{Jtlx4q-Q_FbO-)9!2$?Q=l)l`}ml(nSZA!%HuNoJ(EM}fq8+fO)yV6M z-YC8Lkn!5n*zJLfxG&|KmDbkq*Rza36M5+dR2`j*flrM$`hA*Y5|Gx)oCKwx=#Lo zzptTh%F_)Ir_+!(fC>>6e=QxjFRG8t73k7?X_aG4k&SFN8lgI{aoHa9GG+Bw4m6VRV>O5)hWxAKkbsG-5HzIVcCpk#$ zKDDIje@nkPcVIH*RJ|$XJ|0N)ID;!oJ;L$Snd`LVW2YH*?-g&zJqtFK44%7p+>;7> zcncNujl89H+1l)H%3FKxW?BN`Vx+3a)?|5^11MEd~U zH}?nG)RJGv2okmxlb-ZWJt@MsHaJuC;-F)x;Dp~9%7}2@u;c(ihbr|xdg#M z@2zZvTkO?o{VCbhsk<*N*N;h3?_M3|2$Ugv!HsljWK`y_)PFcPz41X2{1UVb3+c)b zM$t9T72Umb>PBCUBd$p8Juv;8sKcby+y)wkMh&B(XcT0(#cdl7{4Z()I*cwu@4^>0 z+^96*5Z5In;xiOXRpyGCM{Os9W6Rut|CrM^*AR5t-faT@zYA)9d`_QALvVX@w{Tc+ zdl(OanGa%A(|7w;mCzI6fDf*td@%6@`==cQ>kb|Cktq8suPC~n+pbG1Lk zb;ABkx$^GynG;3PTsPRRysL`p@H_1PVqNL8@hzNW3q%b&%yUE7oLhWOGGXR;z{9WBD5Vh;Y( zqNkRrE3YmaPSk$(B|=^JM@W5@?@HXW5@uO}yJq73BHN?qM^20oS)jJYwq6%e z@uYG+Yanv8xQTt=`%q7jTU`cM&%-=6KaPCZe7G`R-zfCj*5>;4ZT*rPr2D6$=by|n z{^L}=Z<45nO8$AOiPS9NtIaqEUn<1Yv#xLY{{3}UJMPPO>~9H$*s0JvSItZ(EX|PA zwb_WDIC}!@KG#ChlJwlAuB!J(1rI(Ez<3Yrn|eYW@{x|u&sAntq%Uy`p>HsCo337 zl+h0Gt;gSZa!!v4zo8rJs2eREzaDNN$anI_iPBT$ytTX)h%n{%$6p^k{(3CPT{fAc z>&xx^UlAXM(^Bzd|DrApa)WW|SdA~*>Ye}Pbz16Ia?nqQ$_Mujem-XqK;G|E-yM2M z7xs1aYx}3>gp{9t=JBqG>)#YHbbCI)@HJqn$iQ98=dnfW$BH+t^kej6k@&({=O}q- z?14e%8~!~Pi7(K;uR4v>P?gv~Qr)D&Dn{j&d9KKbZg@K3tGnmdmsP?e;FsL)OJ6HK zEg6ilonxpC0ysOw0I;{k5?-^@7A^2e83ZRN_;5<1D&cn=7!n&1iin|F9esKI3ifB= zlN!9VlklASlTqGAP`{AJ?a{W0R@iVhZk@c7Yh#$Ou6X!J&^fskJ|0fw28XA3s^Ory z8P1u|cVeG~W6|`*q&gX}T4!$A_wUYAet3DiMJE5|&H1$?cuB?6N3KtJgj_EX#Kf1- z$Jx&1Ok$tyAfS2W@V>Sj!y`>6g36E{ zT;5tjU(!X#H@}N?gKZgorUJTzd^S&(9@$)Q>HignBmMl&?ftWs z=-gyoA-VDJ){mPHeG1K5ER>$^KRCI(m2V$WR0@loCIC1CIXLedvafg(oR9IAN*E-p zpn7msSnG|4u2y@st;-54ZG5^+TYHsc(!9pFgV;d2d@fbY3H%f49%ad16pxJE`_g3a zB188dtz6zmn^E7}MFS}7E=cS$tv|eY%brHSKkBwBzey7^RETfJ<%v zTqmKitTAcw+qKFhFAR%>2=KA*8fd+;6%=#j-C4{fzba_<+TLCNo%ct~#ZDT;XNaBV zPF#pbEuFSFv2>wuH)_kIxlbo;>@KsybfpLOt|Wgo#6%;{;@wcWYburFkNr0)1@&t* z!P0uK@hxWTMob<8P5g!YxHZ|COjD8tFFJP|cZCYXTop_hN}1=Ima7?e_AEAznN2(7 zcqfu|Ih|mjJ6pit#DV=+S7!%l?^pO*roq?0TvaWm;3B_7mSt38dTmkm9+KX9=ZsY@ z#TD!mi9}RWo&=%mx%3%oy`Uq=eaGA8-3}RYnRQ%`hY(mP zfo%TevM-!s19zPE6wYZToVWM^qeSLoOnn4W*Z^XTf*E%`gg(&^edLS{klayDZ&Rhk zzG#3Li|%3rvNI?ETqoJWp_0hlc& z4742!180thfvw54SKEWEyDx04&hrp3FwgKs@H8fyv;TA{uo7%I?K=`j`vybIXyY3n za=OK3Ag&28`Yo>!IImvWzh}841bG|c`W{{MJdYdd`815xXC(j2Kv8(ecuNTN=pgCR z!=-z&_4eV}{{;KRea6WFVL3*E>qLIej`RB`+GH4?L}|j4Vt@9 z#}~t-*uNJ)rs4q}&lSS^m9&JZ6ArV)m;E@r#Ou3;TFkCu@AtQKr9@w%4<1)M z8`=6e^8wb;GhRc|sz_z>B#A-`)ThHkLhbx`4u+TmESDK@4bY(sqhS>XfUue3rh%W&r1@z^?XVE9m7Jt#p=v^;eM8b+Z(e!-ZmKw@6%>D_CPB$@Y6t> zN6`7ny`tE4Eszn9>Z7rv&2?&8y@bcK@}>p;^>owth9w7UU8aTx-(0>z!XmMnVdYU| z$?4GP$qTf4^>RTs|E14;J?uETY8A;`Q*pD!J#58jX)wI^`CIvXU``@Z6`o1WYXCUNJK)x{c;Z%i` z_vpmS(PsLXnzDs~Xnx+e^F=kIwL z;jmr1L#jx8N3ERx4VX{H8eFnbV>`N8DI|hJAe`jqb+<%IBki-Xi=;t)?BqtE&R&jZ zdEXq#xp0n_Av8LepQ_2aS8>a2 z!>MVEJIN6)6XC|YDR`2T|pV#gNUJfN8B*d+6}x;zwYDM-q+Q5 z4V#7ShYbTNIIfu4_QcwlXd>+d)B<#E!pqLtv)=cmp1vU9PilAbpTV)r zF+8|k*D0y&PB7wh4@febsLbxI+ii;{My-2|(Bg29%pVgi+EPCsVV`v+p~at(gk1U=0T>`n2-0P&t3;S`%N?2l2Y$AYaXL$W#KX$F$veX^L zv6O-3nb{J{z4HtA$Msjt8{}Y!{m6SPr*MtlGU;!tm1PShW?CEB`x2MAtruvf_f<FB&6)O zt=@90sGmK$b^=IO`R8p0}~BqP&-lk8AeREzO*=4CmkQ5%zZEXD8raJF^R78qg6`X!5$Ld3(vZZtd5q;k@NIp24#?V``(n#*gyQCF{?NH|A;52A2^b}Avc=)aP=Y+ z-e;EPQ?n30!$I{B_{sQ2nO7acQYmX1I*yMAOq37zA+=rc_wpoYA6y`j4KNZVW50^^;|^Xt6q zfa$lD^EJYK{|9ep9ad$xu6vMFTImiEkro8$k`R!V?vQTj1_?o>OH#TUq(h`ZknU1i zO1jTv7VxdT*V^aW=Q@9S@%qj;#(2j4+`oIwd97n+ODMM+CcAO z_}^kz^|n96m+2n$@5j%tc4U$O?5<7rv_0(0n;ps4x8*Huk^)q>jMvwlgC9yT_ICl5 zJAbJLu>P8@v^V4V-M7UihRk-yc-pD=Z}#Mdyzx55g}}DMES_ssI$wI_SZZTThQROU zdxozbD?eP1Nh?ao|M)vO2YJlFUKK$Aa?WLn5AnU%#sgn|qH9_4C*vOLx8^-HoR!LT zC{)lEY{atxy&AP2LEh(wuY@F5NGAF&Ngp}HirJp#nSm|j;(l?%6mV-{6^E<@ZXEnu zFgZWae|A!@@MM>#?;5W$^KYZdLt4by-d!%Qvr^QQ2+4kDSzzm=8|@CubMkn%WN-4@ z&-TY4ZzH}j!NXqef;45f8zvu93eP(V4*haf{oMMpE3eN>2OF?oW&pHbW~p}c>X(rQ zu6Dz(kk-9<@;r+o10hjVPVCqyK#l$MJ;e{0m+jAeKWV@1iV0Wy${oCpMD&b=gt)?% zw9s7eRUs!};{yG?2@B#$7k(WSu^#WDZ$tA`?6g>=nASFd_| zj%Ca35h3Ii@oG=sp)h;%;N{PWeL8&L=p^M?`q=k^3hEaOssWUm~b@a^0`cTY#z^WdX8Idwu-hDV{QvX!OrnI-LW%^C;;56wNd z9Y3Rr(6rt+d#B>cFAE~nzF1TIZ8b{5z`C-RG>{ensR? z7EgU8nx^TetE>zzAS>g!;TlxfoxUL@iwO9_X60w?auM++=KR*ZUGjz%a>yGp^6b%0lK_u{w~mwp?I&%R zMqcUq34&rqoa^208;7MHt)<2y)pC)_p;5kdPpf4@wRe>o7o!tL41br`5r^S_F^Gg$(yInL@%jr+r1&$7v& z4qbrbg|YK`1Lf|{8tv~;;L7Ce>O@Can&oNPLHrP0D$tp>!nT#JzD#d(u;mM|ddLezO|v}A2rn^dBp+|f5fdc zqk3&djY$D0SDKkB;DNT8y*+U+7YP}XEx$ET z_IfHxA3g*Z;$>74-&}-tUq59b>3XEE-4N)%hGbDVvP3WGS&BI7}G**K&A@% zXahIKCrwQu;G$SZvht@E@I$UFmId`{qGZ2-s~RVLp}RdPac$*0(D+dAA6GWoW6}Gq z=2`+s7l5Cc#_1Bza|gq_@2~ptzm+LvR?_RDMuIPywb%%sYV{J2Or0+9EKT81e`tDp zwPmrcpkf>^>)8wE&m5CoS>NT(0% z{H3X$PO!N!aete*Omi((&X348V{D?EC4V5^RpK53HVhX7=vFKj^#_QcYjs$x{v>$-*v7?h?4K6uNauJF zmzACwkR-oK#nSE|f)4h6$Tm}I?ZaMLL0bhey-ka7;sw;uw;xznj#}K8w8Yl*i&L2o zT?XE>&f~*QQ=2`q(eGdt8f5Lu-o;WeqI(<>%Q6(FW1?y_u#cQuyAkHk%+yqPvn+9tQqdfHmLN#{3C_w?zU8*16^}A{P$I$oc^^%X<67!e1mFu zz8Mpghp-F($S#reLqBuQG37%xBA^lmG$o7o&wsXejA=i9@eMxYMfQLtN|f0~K>2ka zk^F!prTjq%p^ilNt2J+srAegr1TPF*kxqs4=*GDgTlJM?MdQLay<~$vfcu-sq@sa} zYtPgpaRtVa+iD9oyL>Jktm&)2WZ7a>`~38eih#41DFYd)WZGIhrgV#_BUk71zCPc* zP)bUQQgbBiAZQEfng4srqa`*%|N5W@yjzopohBkW0_>mGKO4&t+66A)w zWuMxxk37z(h+mflyQn|bVKNe3Qs$S|y!}A9gLbmYVNY&JdDSvAEkq7{*vK^f!CD9g zo8E@IfCZ={17MFiwNs9^MI+NuX=4!D=q+1=(btIf<2DkC0HY70D50C^gBbfJ`e-eP zQ9JzpZ1I-k!T(huB5GOuMaR{s316;u{MCqK7nnXZecEpUba~!x zzjJhp2*&*X=!81TiLV2k(0wgV=D_Pd<^Qo0Nf4TUQ?gv@j4I9*Ct9B*>I;sBf@(shLJPL*a z71(dfrNgAIc;dR9$!ke(;DF1h(Oql|jt}6sQ9k*tH;V}UrqxKp<)uWk$z^@aGYkhb ztEf22%@tpqV4TD|kK<#j+$Vi?R#js2#l-%@ht>F6Wg}b_Y|7UMn_9>3CMj-!j9)L1 z`ZvE91SOY`K_@tcej4S#y3beQ9**7e5>VyYF?d5!%2o5>!+x12`UenU!HrDvnYmFd zE)rH?3b=|KY$BuMhi+b#{71{r)}$bSM8#i7Pyb>>G$yRXv!okhVF=Aj;{q&T5biPbgE$7t*B@K$_pbuuG&1J^|Vpxe{ai;|>F7Z?clEGJN`;OaUvecf3L0x`9Ab#TV^Yq0+D z1K^to*!4HkfpjrPn{G3(<&7Uq??9@(?Q^nQE{HR*Wav~?yXb&0w6)eYsuZ+MNd$bQ zbj8<`1y3)m0EjWu;&!6MI>j%!ZnfXn2S|52!uvk@ACQrzTV$l|Yi~K%g$CBZ3F8M# z>|#u82`A)fqQB~nOJtZ3NETvaGsyQMBm_Fox0QuS1)P8mH|L)7nQ9l5k^VeDyimGg zqy<}4TftyP+RlBq>+#d27FxrmI1u{;d{xru75m(;nXSXPM}IfuQ2-y=*25f9OCbEr zKz$CR<@?mrE-oAfhChm39=aaqqvHM8W)_oa^kB#5 zi&gydx8y;c>0o7P?uhzZ z5b9A?D05->0!m!Xc&q~Bhl9XtQ1RiOB9bw$!0_78x6DDXmwtsmHL{gHnm-H0i9XBO zG+_r8XWM95z!v8`W!ZFB$&8M%E4OIU0?tO?9@6`2G?JbrR9vBs=Q&6qvS_(7z8aQv z{s^g;$ATVcOL@4(sRl}gJfV8=4vb9tkKU)ex?wf+#q}MSPiNPPD5zP=gIB#Ph*~lL z86Q^=70_iuAu1Q|YqgtGT;s@XWu$!o08u%h7a~4h6k0o0I6c1RsSTjqE$)FPM$^@WabI0w{5(IG({d~-BoeY5cA}0p=EaG zjKoEIn04NCuzL@hHb!XNKgN~!8RtOdny2IL#+?77PILp8F9rt``3m@&<-Uq zq`*uR=_V7k(?ZJL0Q{Xp8G|1Dca)od-|b$_I2h4Bb7Z@1P-Y%X4{#lH1EzPv)!TB3#wJ2p>;XyFQPh|i^s{l18&V%eYou-C;uz2T*AhIhah`8Gg~ zsW^GEv!aKbZBgd@wA}&>HyABX0&M+}30OeHGOzcWm(~*2%Vwp+oDh*KvwUR^%{drF zidzW$uBrR<^%pNS0h%BoYJa%~SoKMGyqANf!$5<9x^K|vix3^)0F9#4rBk370*D4D z8lhU-`@36_@()2+gK_!_YiynKp=crM`03Oj=Mz77nj90Mm}pngB&@ehc>ta0WE0F8 zkL1m`_*1Bl>Q)9r`|_&WKQT#v@ri2Mr5JqBmsQfvt1Y1K-oFC}S&5fQ!h_AroeJv! zKZlv`^g_Qh_5S;=JwesD`xsq^Bf@ca!@HA+A}0ER4eOUdaCv34!AN$w8@phBu~J5w z$r6~ma1;~t2=s?ACHqThza;e=fv3 z2y7cK(5IZo&}1aM`gZ^$c?~8FsjxaxZOlOpJn0;ekds?RYOp5YG;go^85pcmiCH)w zpX5T`U9AP1OO5W}4d2mz$?mS$vxD3Y2^49l#CLJ@xdSfB!nFYM$0?pXq z&)31Hx`kH>5Qova;L?q^U~$5;F5}-IjQ(5&$A5<~Ql@jbZy<~WK0L(T5QstC5@BLq_GSC7pt;u-eugU%wzkQhx~oj5ODl z2Bqa6=L!9h{QFyEUqKC9dv(<+Sr-8%;A<+b5-!e#>?m+9aR4@zNfvsS5(6y1W^W&Jx7$rSj5I zgHl7j9NTWSZ?6FLLuo=|4Uje_BKSKgK0u%0WZJ~hc@%XGx=idcTpK1~u#WKu9D>+9-(1;y-I zrsYD(QYj!AmFdPo!>=QPVQq;+0dQBJR5ndZ3h(@CAc?30Rj%fZsOhFj_=;p>FH z1#H3jX)3&1u50!yU^Pn|j^s1nS*ury%!TI27A#pmCjA&IhxQ#+7n(;JBF;&@-bLkW z*J}D3KuzC51Y7Um&LP%u)uhxf8hnl$6Vua(&+KSTxBv~n8EEVmUVsvb*h-A@j}X5> z6N%^^RKzP{kTl}-8!p~f?VBn>^XTk6FD>dnTnX8&EBWwOnoaYDmYIEzZar*b7EF8M zs(LTnxmd`VCXz0Ezx$`M^oZ!+K1F!*+M4`3}HV|(+Q zi~Y?s@g&`h9~M+>0TL22?e`on1K&$C3N8x*?=j%`lTj$-1sz$EZoyO}PXAj};mBQk z>;HS-{QpU#uoAcbo^y&|y`I)1wqb=509GQ$-K)xY6C4h)D`!t(=->xMbQZl@JWrJP zD?Asc0Xu20zBzya@O`^nT}BPA)9_@x6eQ&JKA$$5%>X}QN+_?^Z-Q+f>FJPdSeA?r zamhqRkLBgp0qH5N`XbD?S!up$NKmQfcKEz zDrsxx8%f?3il|+eD8{_v89Yus+{y1n!7o~*Px-4r$LH}E^5qWa_YlD-!ui)t6!8|9 zQk5lMJjk>lqU7V1pFQ8K&vzun261>?8cGplbhDB+0JtKu@Q~mm^NBmpJ31dfEDg@= z2hCO?%k>JY;$RBq(s1;xOs(VR8`cx|^t|+umj$w4k@th%hOqQ^tuBRK+}kZP{Rj|h zC+^>wzg5`LePTt9T34nIR*EDNaYj((?4XM{g+D%b zn|xM4p?S1i(KQkB*Y<_pyHs7hp-z@We!s~lEf~0va+G#_ihnu~jHN_jcv8KbYzN|j z+Y2GZ0eTR$0YDPV1o@IsEBQEWv4FMntk&foCuk{}!JP^EQ;2Kn^`#N#g!B>c{r)%5 z!mPss&(f>ebBefDp907pw@>(5pBvD*7ky(q$_fFy)AjYJ^{-q6nq8`or!m-{^6t11 za%(iiH}T*xfV}CoI5GNW5lK-v(Y)BSApXzz;kT$oML{0e0P3s1&nez+9O#|41!wLjST( zvS7~pA&5t~7PbcVdGMm+0lOOXWw!#wjS`&Tp0Yfg=d!@u?9nFa7Wo8R4{Te)0B9v( z4T$#V`*4@h5djSzm_2BiZ08owjhNjygZsdhfq?{!$)K-itj3^ZY`q?X%-tEK z6GmJq1VOqge)4O|$vJw5*RFv6Zl`gRF^-)g567xABnFMPtd?w47)1p(@4E{2!+QJA zYjn?A-?e;xrwVeqgG*%y%y7T+xv_ofhaj8b?MzG-Z6p-B z*i5fo%#96$|2ip@><;+WJ1WE(v#sa`U~9lhd>dDAuhbSv=jng1a@}ej0P~pE3acN! z`pVIvz!Z=biu++Nz>dOq-l|tR0cHr7ikD{amRXhyAM3(rqBQLh%vo6cX?R}nDeN1Y zOHpJ481izC*6>s*Nkh2I4|gk4joNI;Ka=9UAQ{I`Z#K*ZSL**Dn_Y%%HfxnwHWc-C zt)rKCBOf=dj%eTW z&7=_|pr6TK=*Ca>Si61;$B+JIYoirBd!r%oC@3e|$-bfulDy2|cBJoz$U_8o4t!hN z{^`LJP#ooR=KJC%SY;2pSk)*>l4gzR@V{iXc7S_+F0`J7CMS-}C~Q5kq6( z#tWkx8_?-!_H>k42g=wmGG&h`qQ~k)hN4R_LbOlW3EA|99VTTxM3rK0oNiwPN!;=8 zZaiMOm1PwIEkqe`ly7LHt09R=i`KZV-~*S=^P{i3zwp$_sO<2*kkbPDU5}mBO#r$W zdUDJkF6&A*D2G{$ipurezkww60H3E|)e5p9rJ!+4s`@pRTI?Du*f9+ld;|AO36R?^ zaA@Cvv=|ob)D2whY*R|7gP(v6eaC$H^kbFN$Gds^jOChO!r|OwCr?CpowrKhBib}2 zG4$A<=&hgyZ}nKVzw$)-t?l-kgn*A|e#KH_5|EmZbmbVN0EXv}Hm4lR#`5%qsW$5| zR#d>Dt7W39O0LT8zC2BC3LucQW!rhBKyjnMx~0h@U#~$gEz$3JV?jt@Fy-z@x7K0X z^ujG}p`ABa`G3hR4izHI&e5VqSZ;Uu{~Lni?ELRFo!{|3HT zHF$1_nDOZ68lY8)SMy{>I$`_0Yr0vIoL4ygk2H6r5Mcb?=cthO1$GduA=J3zLoO1l zr+EjJ7iZ$=VoHAb*)O8cr2rcZX?IfGta#s+Fy=?mL|1as+{$$mYGi?= z?i2~aF$E#i+B_%HbXa$fY-8A)7rJ8V=8i!~&E%Sp5UsiQ>eKRTQ*^sspcP!fY;bih zyCWvj_I6`k24x}9DzRJ9Ds6kOTDUPSfVpu{0Z#R8pkwmI6zt2@dI3V+e>P3r!5*je zzI999VSQ?-2+nmFJ6?wWCIW42SOEy@s(lzmwe1Y>`KrGxr%&sd&{+cTK$Uz}XuX8lsykw)_`O0V(5 zMp1g!!dS(l%Sk`cfy78}dHQe{^M&>HIC9!t(+}jim_X_r;P~J<+DZ3xc9S4ia5_>H$^tbQE!-$i7&q3*7UTmlkiwg}B zQ%wGNGVpYe{3((t!&vdrKh7uN+D-EmDYin9dMwvlsbo0GM1S!WLA7CMdx(hAqyl^^ z?Bkg`?i!7Ey$YI7EyI|GDd!|ZDf%5!l!D7i;tw(k{*qIp@g;o7Uhe0?%oA2=L~}n^ z|79qJ^$txZA6*Yl>8$P0#I)IT_!kDn5KO8H>a(#g?beJ|3&cF0JIFzBvULb2S&fO> zpB4u&BA(`;!we(kIK9{(&kl&l%AR;4eA)FZoJItAb8{`6q%dlN458M`f8^NH7qEtn z(nx<~)WPFIPv!Q!5gleV1y{Uk>yO+c$RQQC4`D)q$+a1WzZsHJa=l?NRERJC*ASI#wh-F$y82VHK*E4NHGWJz|jRt)x&X(%>II$`kM zW9dbjA{ZI_z#t^WL_Zg{L!u>#S8yzkpLx^bO1^S97A@JXAlPvHr8JMPn{)5gj!tgr z2c(Dtzw?adI*t`F9U*~zLEsShYdur9r>*!VkUS4x{aOE$%Fpf8ySiRVe*>#hhFsU2 zL1O~VR+zUeog(!f3l2t(5S=qmDH*;vO+aAx%f_uFB>A1dwX&b&G~a!*vp--8DpF)F zP`oy#4iQ@xM#%Y%X~S7?xMUAGkq}RyggWQ@#Vt-|BBKz;s^3u@{$7*58oUb!=6~iJF1*@YezM%bxs!*d_N-&AA}-+BY1peLJX^NDZ(Xs- z_B~lq;;rld?v?SG1fc7#Bk;AMrrzbZ9cq zGH{q8f7ZY6gZy6#!s{0?pKLPD@QhY>A*n)!q(4_ssi-$8Zb4Bnj1>Crl5tJd{L#IK zQ3?nR_9yUljzu#@iFP z)F00JW;ysqGZ)0;x_#D4^%z}X2Y2Py@hcc(1e@@0ib-<44kB}3)m z{@C}?kD`d5E1t>^#&>GHFUCg6pv>cG(OkveOYb9v&aIQ@9uHt91nV5OQ562DyGGsx z%~K`CrB*NcAG`sq9&mG@I}$@Kfqp_={A z%M(Y~s%>UA5wue`$f|)?8EeI)I_Kb$G7TsxFRx3==y?IEa5qODsVDLmM9fyb z>}GUce>>*~%h!dF|9s=jmVVSF8~dd_Og5i*D^+fvC~rdF-}@@i$Fn_8i~+NeA{~3P zph(ZWKUO0+QQjQaxet07d86}l z8sWp%J2`EXyg>@bopenKB&iFquZ_Nt_MRhF$qx#kO1#nuYL$=Byx4#KqpN9VP>u6~ z@_QHhge7*XPxiO_r0+ISj@5mi-=l<=$B5Jm8`6J(p+7Hqnn}gylPx6GDxBLdK`N7k zcX;^7FEDS>#Zv=OqC|YHq?3FprhdwbYXLgCe(ywHE}p}P^U4N^$cMZ_WYN9|8pC`k zq7vjMANHCDorvkA2<;@$Ox1ao2Mzd15rX-R==axO8_;7kmPvg9jddQ)?U z%!50*7{KBd7EtyF4$;ha16c|g@|H<|Oorg6TN|j5scf^m+Z*R0Ohy_u>Uvyu8uUBH z#vGt*)*Khxs$0mvXobuDA*A^kA3ijynfpCptC&OX17KAeXVs593-g3NefP1^;(Tn# zhyG-Jknp5f+AE6-bOv{>Y+Y4$cttYMBsUU$d=?vrANjcnJ2>M}?cNvd<2Ns`%@jZv zLiT=HZNaeOMhRKnx)KMvpl|J|1 zZ1u}W>E&QGqv2 zrLA2^9GGtqi1is6vKa9W`h+RuDBn7n^WyP9HJJyOu|Mr$0dLnkV7VBIi55i+I~Qq; z(})HQzxPE%W>p>J&>`CQHpNXrF#MktQUh?CHd~t9Qms}Sig=(I)nHJt!Yj`zcO!9k1(~IcJP8bVq{(3{ zm)#Z#?Ql(9-{vWqDN;_zfdXycnsJf37+QnoT8`~ujFIep-ktt{ywV>gv2%Ca4boc(IylW%^SpC@1GkGIGR3a?dkMF|Y?yP>H3|H08DVvk}kbQAe#Y7##y{qq}TJWi!4Tu4qjI9H0ollQB4vP{ZZGZ2K9fj(e z*#=f6L>;aTf<`Ri?{_W^G5*)btaxCupqXwsd>5&hUHI@8lCXKGr6nBq`z4UZgWVZ8 zwk}TR3bQfHzJ8__yjCfqF|?IF7)9=D8?QOOuVIc@wHS%g9%Ful5ql;cgdqP>z&*b5 z4`TI7h74l(5Pr|{s0LdN@(EzuML<=G%D<=-9mc8{^wjE$TJprkuL_#7c_I^^UL_N} zarqHnKE>VCaC)wTT$KY=@u!Nro5iga77Wo^slnvtF#7hGM8ylNy#`!~HlsKDmxfvR zrrNm*wIlzWlY+!GAJEW@`PStdd0`;R8?fZ9Lh|jzVr6}o__y85#DZ@eQo}bUG`13H`W_AI8YdeD@F5CoBWXXO-=jh%YEmKjj+lQW z#VRVjqrLwJT2oU(wxX7|8c%KL{H$VgXD4zPvxg}y+B4m0^LfNqW!?5jrQKUMTc(J^ z9C6*zVFp4NA+LSme01G&_PyOuLZiSwe zPbQBI3&{5|KX*FAl#_t2l(z?cG^PX=?%E$u6}V6pV1h^AILJh`2@uoXpsxY`+dE z=JFa=FBWsm<%mOk9xtfI(Eo;hBCT##R$cw%y`VX)fjz!@@h=W8eaV-ui${`7W_0kK zKVKsinsz%|uk&TA5>5ez=W2?z`enUX97y@`)^U*SW5?-ILSFXDj>V~UyJ_kBs+Ex~ zi7p@D;CkM{lDtp-6FRtD+)nv0OQX#x8EXztqn?s01r&P_q1*OkG(02}9D@Pt3#Q%x zai#EA-$fMMY4nNo?2*^M&Xc!mtV^asmy5ll5%+C2w6&3mFie%xdKpXP>Pee>y4KXb zM>>RvwZz(6@e;z2PIvEUfh=hQA&z_ex22en;U+h2c6171<}*`rH?@RStIrrO+sCHn zY`;?7)j!!F#+H;tZFx`77GRHmk;!oZyQUTXN(xaZWka9<*MysWpV>D=w$uBrtxlxA zijodN_=AWKH0z;Lnj|Mn+_pI-22B1U`qExy1nI+fEZR~pU1n&zp5|!WM}6;a%8;w8 z=JX6cSxKjc=)EaVIb)MD@3%D=C97t>-V%#2zG^>s;S#o1=7d;XHx=)B%Xgfw>sB!5 z%n?m01ma7KlP^qXMA5t};edVbUfla9ydxZlB?zIzy5`NF+`Dw``0crg8}+o{yM^e5 zZS}%;3`oM6x(hW2pKN4?RF}^_W{#O@e@&Qe$~v zsU%>DYP3BsoTowW+SO@?>Q8|_zV2N}?d!-2=!ZTGBS2j>&&46Egf;qZU15|@H4G!1(Vm#-GQpM9e5rx4TPnw6XJwWSF^q4VB2 zmqAO#ikQYx#r@HkmhSp4O8*3kE14K_B@syDB#o?cSsE zq90oQM_PhB&8Qg;mxBAZmKx@0@4qY&$Sn!PI5i}r!o}LVar;`Hbkq!k$J4b;)& zU%L&e7unk=|HhAD5v2XRN z(owyiT+^g8Ndd}&{bKX_wZij;=A2%2xlB|xF@asuxj{98!-f2)Fz=kmTKNIcOy1BP zIWFkVDP*F_?8t>xDrj|4w4ZUc%U#EfqAfM`dTmxh`kI#s*7aJNSr>hj9^w%6x4{hUs!heDp$GUh`fHlDSyCC-af+<$PG zj^_F;)VnS@-_Yi4YF2ddjwbIC?gkHh!t#@B`ptxO^i&OaR257U^|k9MBx zQ7CWsW7W%dF|8lWMo9f+_y4L^^-=ZEbakjTqx7&luRwu{gU7QZMEm*aY{=#Qa{d{b z%+01?R>o5u3uazutEO2L`??|QLuEd{&+t`4LOwLeYRPt-?{O<-PWvPG4yJPryVY5< zZf3fG=p1;6MQd=fX?siJB;g@8X<#lh0xa6vF;YX2Ker|+q3_!<;rFL_j3Z`nKmcUg z*)J}y3pw*Wz|Uu->Uh$ogjOC@a3Dn#*H|&TcT-fX`@wE|$Wh6_5@yb|9y~??HnVct zE`&rcmc-*uFIzgjs}rITK|O8}6H^h&a`ok`fjt34ZdVvhFxy^q<=$+GG-w*ewQ6Ai zeV-n*kznHeh(@{95qshOoRj(bI`+4SY_UY$k)!t~{L`;rjDxxL`*(R}JH$&%@jUU1p*8DfxMkSz z;Ne?EeeqnZA>p6}I_7|0sGE^`#G`}cuH!0iIpl53|E@=NDnLD_J7g$(3Dz;zKkTZv zxT~q=mui+@(vKYYHgqEvs~VIF$i?5g1~J3lsHE_n0;& zr68)vy3$_t58!NA>a|FUxS)rCVKN{55{C&=>`YLcOvTXmI`{ z=g{cZ<_UtZjPUldP2WHh*+Ppg_oMntkMAO*4Sm`)2)!&`7^t>ts$_n35hXU+xew0;i6CuQOX0CBmX2`KhF~G7jVt?s^)Isie1v+u z?^*;lQ`K8+YhJ*mXh|1=Z2V6zt=XjO&Y$x`Dn8<4K>epoK4*J*FX=u_My-qSyrb>} zrwy%9v!)zbj+HCBH*hUj(eC5+jf|!(H*nfeuqvvd0E$9BR*B94WBBK};4V3!al14= z8ufvrPI3*X&hxUi=J-(ZLY+50hM{s)5{P{bFp97}P!*vz+zGbq#Zo6X!P0K*{%1i= z-jzoT=i*Yy)LQH$P^F%P)yM`jf?KR6NRqy>2pMxfS>dGm47(Xd(TfEo8sfT5Ou(x& z?fmq-zg=9@?=A^=)mA8_`L!CLn#>E;_Ioz<%rKRRC2#+wqL928k-68iRB8b-?%d9w zKX@qe`Xkm096hiv>zhb3_s01aMfwIaM)X}C!64Qa53tDrv@E*6GISEc;hQr)&AcbiMruhC4(f!Q?-Y(Eo9BQeKjA`;& zW+H`HJ)^Lp+}RutryLI+KLA&xWi_okC{XL4FChj&pfF`7^gmh2Uu$+6DgJ3CubykD z^?ioFskMDO@95XZkbF=gjQ<}qs=pO+Q?7Dy#8mXJztECOy^h||8E7cJWK>bO`~k3m z1{(P-;XrFs!0uAUW$II5=+NY0jKhE{zp5P>GYWlB8)z+#8tuAjg`GDEaB;rSkUnug zX4S_QCLk=tR$CN#LtP@;Hu5q zEsQn)8PvZH7Mr^5{L(r1%#o{jJBFz&``So1*D;LceWSy%+T9NmMaMxTi6?(N#9V$p zuI*@|a&Jq_?Wk3mqPJ{-ht^3VA#!u=i{Gr@V%Phvs=J#(C;bf@st7j8?++Zhvw+PELaF1yz$ATDYFKqJ9|P87ot5M)>~*Ts`*O{hf%qdrY_f zI;6&>|CQQFSS;he)*yMj;v63?@yTxJgfv2oO=^i&|KXi*dg&YK#tIb-YYN|LTTquT zJR|7nunchY!PYa{mq9don@?fKO?Rmf57Fx_rWJ!g3wGTN=_T{ax8v_i?_-ThbRe#HUqm(w{}Su9 z{&mS%6tFJH)Ar(X5a_{SIcL~p7%gM4!vLccf;D_a| z2-{H0@jnb=K<&XDqPtalN_bh4yZRgR`w;OcfIM(}{)`JIAAUdRmLsjvEvW;wqnZMC zOJO=luFmuy+~^UG3*~>h(VUL_F*wyz05|&lq>Y8n76(GBn%{btOm(BT(S3Xkaz0(K zv;IaX->?Ku(d;rZy`j{^Els6*G0xSJJ?a;e@W^I*oR|VnY%cw;=9PwGe!TDMm$fGH z4Xcg(g>axZ)}nee;E5GS0Ub=F%1Ib-@>i8($wfvJr2YUJhW@lF<+f|Rg@o)HaphV! zVlaVD25_y{RDTjtf>Rse?fSoj{R=uN7HpMf@?;=I=z$iJ92Nlubcm3KY+e6GKnzr%`|kw8w;m3#mZS?nhtH)-<20p3aJCIIbQd*$Y`AI@huv z7HfMZ$RmtlTDykkiA^Pa&KRJdk67?f;D( z9ogvock{5tt>L@Na4N9T^mv$Q_CDs-b>_wBI};kr#vKO}StJwJYThm%;E>+yff=+L zv+Z^y&-5fq{~ZtQf8>(yN0Yv(x@uNpD}+&A`v9fyY8>vK5$-|}M&^>y(n2{L(H-_sc*>>b5z zf9M0jV8O*L3er}3Rs8?R?(&+F236Z!;S|gA93I39k)?PDJcK&Ux6?c zlr@CAhlx<;*Fvjrb4V+E`NU9UhZ-WFy6-ee$TI!MXiiM&P9yn0rH|vGk!sl1`R=dT zZcF$wN<0YYA`W`YJmWh4B~(Hm3$((Lw&tAu#(~B_LY6$>G;&PHp~;U+7q<(|{+fA( zPmRd57W;O%A|>Rx#qW@G*Zs~+wj1EF?&KhWmYsl-zZvckSY+2qqI1(s~MZa5`x`s-DNR7|f$vV4i^NPTgd2Rn#uu z$y1PN;Ty~3d1x4zP6-+oqyYt2IK94-#D>#sE3X^0+z|f`=i-xa>Qb30TI}8DfG{w7 zGEx=TG953KQx8{Fh>$TPqlrbl$TwR>CqD3<+)IL}PP=B>!XS$a1krd|MLWrkk*@nJ zceHK^C^+S1ZO*x~e%&Bv`4UDO3PX}mE^pp_3yFI#m~&UEM8&jJlI$ePO7ukuyI-YR z@hjDXFsDy#(%+nEvhcllKAeuVqVIH*0vh7aK zh(c1~2T?h`;X3X!3kz-z?)hviwPN`X!-D2bL49ocdu-J)HzP1d0106yXkM|6rm(Na zJq!y9 zyqSL?T_2|5OIL1Ir&&PxL|t?D)m`1Neys8bNw)f(MC{Zh0T*9&Oy{ZMca^YE`0LPy z2dVroLtQ8;Icrni>dhK`veixOm4~k0>#$yu_-cG3F=2+@?lxJ^$Fb!#==#kAGl32v zSw^=pRS1&6rVgI?lpP?C0XAB8<+XfJubZSEZ6txht3$T_K)^rg5+LVylZOFvej8VZ zNNy-1fj=m-0Bz3k>7JNbtzZ02*j0R>7a;Ht*rn~llo2fjgk6qsMn5623rPV%-o=U+ zKQHA4rV>)I3(CQY^!}qk7$a855r^?6W|I6Yfec>x==vxQXQIku@&nwQ7Xx|aI6lKG zxp2xAi#%2KWJ6NEqZ6JSB-obgjfamP0KvwWfWxJ#U=+P*T2pZLbpQ?vqUO+MF%1*{HW~T&zoEhhC8JL4; zCGqcAGxwKl(BVZoTZ565DLAdhegBSG<6$Qng(J5#1!|!ICYe-=PRy@$cLkF`$XF!R zK5HqfC%2=CpV|=5?s2C<7{0IAQZ9=2P9~W3{M9bSDt#=97!4@X=w7rJm1kvWvCv+;NbDh2KYEFi!v+p~zqDkbJZm@i zL7y(-zpMi%7J2KAunv@x-A@j`@c&43&|(9MWr}1{K5g7}yOeyNj}MRfI4WF8Ab6}O zBy8Kd&esv=PAvldlT>*F`Ux@KgRDkgwGLihPXpn>r((6#Ly~ny;_Ih_1l>b~7^qnUE^o#Id(cOL}LCRmr|peY${hNVNzz z1}w)8Zzr~ezEhsxWUPG%b??D!=ZtoUVS!$L(`%A^iGqE!_4U5-F%F^Nq-zJ*jsKkC zK8&lcD_5W)0+iFNvbIPyrn}O__;l>gA_zBG*rPLmmKxn;(;4?4Y6dvOkVr(U(Px$u z&GqhE;=;4*chS^Uj0O&xglFO3Nx{p#!r0#BfJm zMJ;|vrWOQolJAY|s6Z=XvPpL6ZiMJ9UDmMnyQo@F4%+~_p19}K*@n6t77sRlJ(vxM z$Qb4vAxvijHsy2c)*0SvlA=rUrsF)Uz%)p!5#dvZwzw@$+swKYv%?SP2`OLiXy zc!zr#M_q!}OjUp^kb&hsekhU9rbB`dzD6fGU#wSiJ5N^eulIO{N6;jS$1in9j8nFR zf^$czWewL$N0YhS7NxRj7xVQyj9(KHqK~c}{HxSqKF*RydLTIl^uYuWG}=w)qMqAq zDp}+`4FUrzXC9at1XnCUQYenY*xjFA88KK18L`UIeg{76cpWAd<$%(M2mV@Wm2&qK zbo7%+R=>J{v|UTxcjl&pd3Mix9&Q#K*2UZfZ+LK~XA(rb&LA$CY$ZRTJQBW>lER6& z?M-@d{-!U(F>cA@V8f%~pmJ{t*@2<}*O(P|Lyoa_kMEGx>To23BX!y1uO@OHoJu`{ z>)Un4(!TRQll5;m3YMy|{s@61LK<$I?wjp1o5ggS^nK^su7XMdB?#OeX|B7byAucU z9_hc2B#Rua8gN4jxvXES|M1N_M5%;rIsq{p7blz$w;L&(O7|-LXX7t4-mW`R8wvvb zH-OCPI|(h{uGc+9UrZ%4YF;|5Px-p~qYJQSA{Tcrrl?*b&L_(M@=Et={ zt0P_kWRc=hLxhj%T|inV4e?u6YurWVG2qK4d(jvjxx<+=XMYHmz=K0N0rOTazsOQH zsmH$?kV9Uk0tV|5aujhaIg%)+zac_21t&|VQz?4q^l&g^O2pl$b(+!=_EUdOF$(2K@c!~H~RXzq}A{^z4sgN|SF^pvq%^U7! zq-R9W3)~+ou>?iZ`cU7RT8BTFvq}P;?1W8umt7t@-}+Erua;y&Rqr2#PxZaM89Y`| z^GEl~Y|H4`#O@@`J(yYUicq%eUX6VV?Fo2To7iB|QLGAdFb3R>vuZ#&5%Y)R#y8mCHrQFlcQdujJy<=rh1mU&94hTL zBo_&b`jKHrFo3pu|7i0wtrRTCn*r3mac5uA=vxKAsG(LU7trh3>p(8+AY;2tuxrA< zb>NaO;g9)`5+(ACFIUq6Ry$zSsZ$X;!jerM|71|ey;Y>xZ5sz`1sxuAU>b8n`aS1g zklaWt4N|19Dk9Zvza6^DP}w=5u+0vpSKe4XHn- z;VT1*krUpZOy8Tu=wCWEuWB6*lHb?+%a}tJsXJ~Ys?UyW*Y(zeNiu!;AHrM*6O(7M zxDF?)lih2RJp^$|lxyn(5~(^;cgNoKW9sPY}x8&VnR9_hkVr( zzb)Ho-!(^}F8G?@|FNy>5wlWdb%TyW-i9Nv&QS&E-@e6qa3i(e$8NFK^WV`W@o!xH=;>7xWAGrt8#-Khd*-MVZFPKz z@fY!OGColEXto_3bz{THCBV`)wwbffAR1FFt^rO(8Z7Bgd4 z*RKfGF5frCkK&q5dDx(tvSz;Nhg$41uYM>Ipg;5`SqH`3PkIEh5NSA}*}N1PyJuEZ zevr|4(jyy1YDVZgcBf;Fxl*T{Z!vv#N~61b;y{i2#f})K7s6s^@!kK!-B(9N6}|0> zg(89iibzR!x0H%>3DO}g-5moe0wUeb&|Q+!BGNH*!$=N|Gz>BKpn@3pe(PJmd)Hm- z`(p^5bLQ-Q_I}>?dEVzeV0^m_{zgwD{i1^|U8m=lP6TMq7n;=_(ouFEjCLKF4k36IEdebE`|4Gg`$*YcMG3OsH=~pFnX3XbNXjS!NS9l`- zYTRt}qn~Z0hqf1JZ`y_YmOZKbE-yt~`BbUNf%9J>(V7oF`9F{-=Kl&3g}W?r6_?_< zEwGJ$$VF4P{hC!8i(Izqe&4u-1cm7SMX)zSvYiZ8RZ-M5Pjl)-mVNT zJaa$m|0eWkR8z#DUicXdfwX2({Wd=FPoMw)mDDHVXr4~oGvHS`g^l=T!q7a{LT=BE zL2V5ceOz+6pD|bF(q!+Hgj=r*@GzRWs}Ys>qW5~uVF^lawC_o^GxFusf8(fLM}M{( zY@*G4>oncX^ulp@D~2W!cqtjLzVPCiF0*RX^97Bkpz zYidF|bCqXlnZ4?dN*fp_r%|ByqDw!?cV@rbD>rf67m5Qs@#Lu>z%i)Re3s_V6r6hMs{UT%h+@+||{ zO#23A!nPZrvcFc}(zA*egZuLWzu7uWUfPyBIj8=n$LTqN z^hojd^eAt}H8bMMAf3^#WXsA=k;(HkqyjA@Vpm(!ecSc2TGGr<+eq45V^FQzH1Rm^ za;ZiV|7?4$Ea2XopnFfR!g})zj$)Qv%8&yoZlUbTUUR3x`GSnexEBe-Qn*$f5>#$v znLH-+Lt%&R(9DmF_Pt*35e+Q6hqyn}f$t&lv zO8j?`+YSGMvHQ5(`MgS^=wlw4fSW`KM$Da`hM`S8qypAIP6YIoo^R?n>DCb0*7nN$ zdWyYHdxUY@>ARVoM+4l3C^~0d0=%sPptXu$d44i?e~iSX*p3H3Y1@Q3X&&9tmj|U6 z3LpB?4Xxvj>sAUFq2-b_X*fwL)@KVS;(yGdgVp68Bs7ZkI9&gaK?qud{x*j!=AF;# zk!vdIS;CX~Tf&pQ8=8Mc_Ry>(sw>^kvAzFugGT;lcZ|{h7ZBpODgh=Mbi*DqJxH|G zNjAJ1O_JbYTTzKXs|M@2Rt?eG^74rE5}rI$uW9l2){eq1yz35cq#c^V zDDvmRdzluFPg}(uUcNHCuzb^%#{F3Q8xhiX@#PbXyCj6ym0}m|Q)-zz(Q>I1YV-Mm zz^AXEYZ)8gcF!UYU+++3FZ6dJraC{iz3`P|mvIE49{KswLCKFcJrGr`)vb1Q5tx}* zNK3!Yqw}3L7q1d-#@=U0@IH+lQ!IWfRjH^&%jFj^jlXInctz4Ykp&bWUgaWox5PAB-L+n=N(Mzxi*L~ z8^-qk?pcW^&Yg9rHOAxwl(_G5;l`eV68AcOPC4@M*owuwYloNKlTmt3enFkCM?r2S zQ-o^m(rD=$UU94I*FCij&#FcmTdp<}2b)b0es}&Giw{*J3oY(_yB6Xd`L_A8H)gbamAoJSO!axh~F0%^XU?6Lvh)a3#n%(QC;-qSyP{#@g(DuELS4xka z513E2Cv!A;O6K~fzxdhc&SXu$E~aI7E;KCS%6F{+NU!*QZ!6mYC798jXjE&vy?Uob z`$+NMGqh;*54ofOIHtj+hS<+)dIP`J^em_AqwPp9bGq?gIVU^i?@Fc;owiy!xvZlH z?7nG_GXZ+f5}9}LDdohU-R!;3c8ia$bBm+HD@Dh|%mTRYZ<&tR@0_j6hp2A7xQGkR z3@zm3m(CcuQ)Hd+ri!Ut|Ud;p=WDF$TPt$wO!k1fT!*S6nW8P`?;<2U$h5N0K!H;+>_+Rg8d79R3 z&3OLanRc0bvbv@G=AMU^mM0M>Q=LNrPu=ch?%d$Bvqm}4%SZmU(9o&h@8TL2IHLFI zp5Je^!~mCSI-#{dZIN&a9DltKCfA(0^(9r2@J@yt;Jz}*@x2+<%@X>lNxGSX zVx3GZc1M0b0gWy2)}8ScdHEmG=(gdv&nIuyxMz-)c|yZcPH4E#oSx!97(0Q7W#!gD z5q03tvpVQ~?8X_&_vLv1y{hVQQdJeS9#O5a(rFt<+Z0?J&9owEANOZQt@FO#=q`Wl zm|)I76!W3SXpqyBAfw2EjG%Qx%d}d9ITCs%|4Z>&D&B_g6hyiliaEPAXbCM|hUHj( zirJ3zH1Ig|752eAYA9^)k1c1KGxJgwSiIXZCSqNdEFn<*#I-TG!TVUdyf*w!^c4et znVZ8-KquRiq{jS)az26~n3UvFph|NX3AP!gwGWiqf}4+K`KWSa8d|smm0U^|ut<^% zJC%UT2EDd}#@I>A0yQba)9!g6KkJrE+TB)GPxWKba;f3&&O~|JkCZd zt*ivzBq~LpkrM1`mkg>#%TFv4G)yi?oz;g^!R!tI!!+@px$6PyC>QaMQL9+ z(HuMt$y!Sy>ZSK=De(V#aY*9u~+$Wj&IL~ z%zT-+v|7f+@13C;(gK4{y{5nDw*()X)G*q#M?UMFd!ApvT%N9@zU+q1(&XgTd+v&2 zuRI7xK3#noao-FqlWLXtzP3{gze!2CbpmDzx`!-w%2b^JA`w|*kx=<+1QKpPB0{eF1$>MVSn5K0Ztl85z4$n`+#~MTt zy{SNYFJ22LUf#iT?hEU5N6!kP32~@_m`1?ejtCLEh&>H30*2r_=10^5-w(hL#1a4T zDB`#lF^E`4?1K>pwOqT|+YqdvfTZda6-hU+acmOA2F^Ky_t|&+00)-z)t|$nXj!e={{O} z?^c<|r(WPz^L}X-@z4sXH+&3wmC5L;2yDS_de{owc>(Iihd5e0T8kl>-cYXLjgne7 z<7cM7l$WR?_OMDt+|Chxmvk|=eirn3GaJ13tZ;3qmm*G;^zIJM!tN&#ain50fsNcN z?{3ETEo)KVT_(S|eIHSp-AsW`m*TASN-7}ijSXGTq*|=?AP8%j0N`%PI{$5be0fd|Q)aj&65h>6peR0c9Un$C{n+UQM7R)W)GCe2eX< zUtvYt-k|MyPc7FXRf$G1wLlNu6_1<#eI`Ux2)j!YR)n?wwb=>!nWjYJ$z-!}Y`0R( z$?!WHxSAkE7RO3t$@3fo`h`gn{rSWsIjSf(a7i<91jsKgH&)H^fyUil);%Xe@I=0B zcphY&5gv?|KM-7##y^^+zKmw-C!eza0!LbOt`%6TU&80Eq78jo#v;n#v{wd z((?}(XdS3$z{tHh4%AjR`(=A3`&D`dw<7vV+KzPum(k1}TjAm(S@Di*DyOqdgmHt9 zaK6Uo4wNZ05n(LKO)wCKqRm>!sVmlG(jz-^+?BdWmZ?~NGaB+?zuL< zR!5|gP;E=rc8u8jYWHI1&#oPby6#&Yjlq7Q%o~DKNAU9Ipax}+!)?vzer3Va1ps&a zA~UtO(P!G$X70E{xJqk_rzlOt5k=OU}Mnumy}w_2V<+pt>QFI z;_KW??7k$XcqTf652qS)@Rp0JVjrZMjVdt;X=F*;VNA${EL1lL6)T0^Ub@vf&ypC+ z5e(Z=?V?*$2YqW1ZgiqL3|aFDTktfsEL~rrHCYoKYaZN)dK@oN>Z&@VSjbu7J1UtA!anNF7femXb@WV%~p;BZ7%VZbZK!==GDU7nMLc-J} zzdm{KD0!-E&QN1gaIlLabxmg5*?NxR#xxfr#$&(Zom#~4Q>uunxl?B@DROs|<6eVKn;3?8OKH3Yy`)gmuXh(;v zwaq;FP&&whTE=qZ#{(AJ5XYO3$FpMdxO+0yH@nc5rgEm2qLdI4R&p}|{F!!dSE?Up zjW9MAJl@=N>T3@iSy~bLILmj5#X{Wc#l`|v`fAJLhp|4^{$SYDVT?tV ziw=mK>z#^*ppa4-)?IcHSr$);%R_#SZJ?_{^+v@sTYZ9IuD z16>;#(FE+h=gT{L&a0RcDqR$pqz`@9yF|nNjB*F(aD@@`Y!@yYjaH0er7LvC;`vJ+ z`uDA&Ho^to?AG+8U9Zf)YPcPhvM&(4TX#>V?Dy@HK}KQjJ4AMwstr;-OP;Dfz@>ed zvzg1})~}Xy02Y}3S;>t zYQN?506JcKGj z-``U>o=DfGt9>7NxuLl^&_?{RmOBZX>bt$#@mD8-1!i7}0w2I8xZBH1%WlqX{6GXM z_G3HgPag7ROi;r8ws8i*z3&nhBZ6-KxixB5YYV?-2D%YQ6isEGp{+)*hG{>&omVLj z*-_a07XqFsswgP9c$vdbz93ev0x{GTAN=M8$q`Rx+D)KHMc1 zWu~+&#eaNM9{=+r%99W%$A30XAl46`#(Hq(Je%&{F?WG#o~;KGVq`=pSvU#gDu*gz zOHI`G1gk&rh1}7}a=P=6v;uykKj6u+BctSY^7%oToDRz4pM#3y6MYQ1eb;=RfR2bF z>-B@P?e4MJL_OS=iY2rmQDFb3Y51pzM+qurQt}UC4;KP+O6`h3?v;f6VKers8AB>?^}r zhjM5A+_#n~e(t6@BEn;lVeZv_5h1~Srno-E^Wxhri$^giOx0yW@9t)w#|Q%C3c>1Z z^t_zfw)9mR<25nX`od6~y+Z0X@LnNaTY&Gn?)?CTvnzu1mPtQXjj=1MDc(JB-YkIT z-$F-P2!HeWs<2V%t#!9bB=hnBLJB2=?pD6`XJmSxe#YaL$Gp->17ZXmE-JE~0AU6` zqJ(`=<0*LEfGb>hc-mLk_%z9}diFddqa?WLCiom^Z)103^QidG%Itjn+8uqG_~G^S zeR!H%R2}1_IK;!$U_QLynt(5$3hlebC zy^j5m&g?GLo~Gmu;fTjipao3K1H_j)uM2MpbJBY^YK-q8mYA-Z54zdw)UTPvJ}S#Q zSU>or9VTnWSD=#G@+&)$#{>&(^-GF{SA5i^%JxLhH&@ z$@HSBuToTwmW<0vEe6VPYmpoGgx#04V+ozB+S*)#u!(A>W}B@rr|}B$=GO0yqj;ON zmZt_5JPwMcBCUd&6|1gV*G8lhk}45A2Ir~otk#X_d3G<(dC|PV1QptqGqWpKn#|h6 z%b~9^m#_-A+zq92o}X@(6tEkaV=lEij=p_sR*i_g&ljXk0vw!RGb&0Gis3)HfR)i{nU_f7&oi|ScQd0mAwRMLQ zou&!o&Rn^NQvACyH6%U~G{U{_xrcK=OFcJ70rE52Y63;xk|ShK$zELU)Z8>#dE5O- zLPSW&u?*`zyMZi=mmJoRpGzAk-u8Gu-=GH+xWitOp7>uQV!VA>upHmr7qrxt)4 zk>sm=QANwJu-G|ei#*;TMsGT_f#6QZrP&GQN0;9>*r5A#jCS6?)>9UY2AhhVhADH_ zqGxfuchvzkZo^oKGvIpv;%xc< z%Nw8{#`1ZD*_v3}C-l%abMasFa0w#E|D6Z-2M`ZF1MuNRE*VJDtyI2p2!CWFbW5Mw z>E>T|X3y3M#mR4LGbMUNIK<>5KxAtbX5k-Dgk;QfAi52aSug(1q2U$BPqvd!0zMFo zPca%GqS$AHO8n=b(xqj)tlu`^RtSqXdmB9v(GWjNGCqjy6wYh#H>PD-lal|;gcZP0 zIg$2zJ+0Rc*t~*o_Hf{ev&*(NW2bH{!R`y+Rlc(^=x(T>eCL#(Ex>LItG1=sMRad0 zW~(EKqglYE@uZ1l??DO5I5__^}EoHHXF3MrE(k{yW zv%-xI%znZ&XA=Wk7){U2m8?|N7&$nqb{tw$eCPG*j~omLM2g=7QR;7jh(gAgEC82} z?i}bcBn?;fwGu4DMOt6|;*QZzbHjMd_KH(be=Zl(yxMm)U%Rbn0}7k21Pq)m`k90@ ze=?)EmGQpO4ZAXPMf`qN`kT|1pAIMt^+cS|Ivu5Fo4|(E@gs0h zEP(uUNg;0^2CY?e>u-rhInTVkD!|N&_8OR(X60#4MAW7ErB3~i+^tQDLi_vEFmN5X zGuzefg~voNAAu=f1u6#I(=X`5T^tK3&LsZNmZGf3i;W14049gZ<4RmySNrM96}IC6 zP~^MWp;nu(`>D@3Eu06GR3P9sKdol39iPfq6C0_YC=64!?r!GE76gv?&LkzXLgTp$ zGsSHIB>>nnrh29P!e9?Gx1|UD^tsh#oFxZ)mE@hV(HXa|2>i_@m$?qBwvB6nB$$%H z+!^BIc_z)!ch+8qy|VdEDlvQh-g^Mcv)IW~xj5x3D~c0*a}WTh!4Wn4ol?+LfkSB@ zw2N2jsbS}!=T^y21&O}1Qf9kwYOG?n7M#@;6e;{8$IMk=$d(FkTk%M3`)eoR`bs;a z6@tT&GDlUx*>YT>4hNmrn$GQrNws(Nd)=@t!xD($VYu#>hi{qT5|l8%nR2e%6@s8= zgkR8R0%qUjrpI}t4)M7`Ku)SR;JRPE!B+?#wiL?bZjZQ3&lB=yfghQw+Q&@U95@Ci z1}t;!T5z(jbIaDU+*?AwK5-xxL%v*dKc!zkcn)230$Im*T&$+#!iTz$XkLkiH{&UZ z;jvXr+Sn*5wEVl_F`@Cwuy^a$?PZO$8O`X;JRyCJQC{7$YbJ3+99z^hQY zI1!#4bP0^mGGPuWsNEfStlS4F|M%TMguK478;rhdG&a4fTwaS_RTdHAu{~{3Vb9aE zMxBF$**4FSXPhom42^CM`FeO3XaqZ@KvflDjKt|3#CnF0wD{n>AepPN%QBJCM=eUEx z;`vWCwb4UR;k%kDuW(*XZ5UwABs3b3zOq7Jw*nRTI5RF_VETd}*qln_eu=jT&+?7A zxe&S93y~>b%{x*DTi2QGlkQ*d89Yl-+;R%5W3fVOAE-2{s3cW;aD-tv-!RmBdlW6u za&;lbj|`VeZ^lO!zHRMC;!}XKzXZtW1;42E=DXxnyg7zvY^7HZ)wpIYjo^M4OzZQUeAQU*JrDOc*;23&1BXV-ET0EE~I|Du|`bQ zdvkQkWO`J2=vcR2k;k1U>SdGSncU7N4duf$&-N6U8TqN_Vme`_y70fg|B`Nh;Nq97 z(ndSCysr?3E=|{&O?A0Qe>DrFxe_ExULkwi@N|P(J%go-^o9BZ3n#+g&;|Ew>dHA0 z#D@}=NuiRRaunz29-!x3x5u?)l5%uGlZd|V8 z?X<+c4xeP|=fH$Oiz=^FEjnadmfs7w!b?&D)I^L?0+~};aL{)!yc7ueUGb>ig)(;s zy%+hV4nIUhE^u!i<*y|f&xaK5M$YzKnYA-PWY| z@-zS!x!T2tNd@Qy_aUyrT|qn>E;do5TLGrY_mhu}aV(?_lF*-6i|QUP8okj7uyj0$ z#5AtLO*RPoc{>~aG(v|Z5iUjGD?eh~y03d*`qqze zPv1klHSkB0J1|#)E1xfq{YcL@E^`h;aSkI|2CGoRnsWF7sOW<(Nvf}lj96{m-j}*# zqwBsbUB9WmS+J}d3CxY1a@O7~*4H~IQHJxmLQMi|hLs9~WQA%dQ=ytJVwPG+`E;}) zA#cOya_pO-VtixSmH|-MTn%p6{zDRS00whC_k{$W3l05!@Q8KhXB#Dk-0C}Jceq3Y z4?4>rrl`JLY~-c1@(-s9*;Vc2CG&jfx>lBYhsEMm=>l0~@KnzB5l6Z}SqA!|`;g#W zajW|H-h1^{#&P-S$JHecD!mk!WDZe}cBM9*ibqvL24D2%=iE&i)Vwt`pZrM*V{oZc z3uHcRtN%9bxO#s*1d0>i;)JUaNd!K&P7h`-6=gTi_w@=8=&5FG+yODON{PSLufG~& zs%Wbg7Bq&j%+*AHM^s(PoXR|PdyFhg4-_0ey^Fo!>LecW9mSEM->81yJ_}i2)=(rCr@M422ov4D&PO~b>^`287#>%V zlt{=Urp7)(=&>K6PrG#7llyo~MS0rP^fId7-5C)ncuxc#vmz>-ZM3E!o9ufl$3`*0?=aY~dthypDZ8aVMd$?%<`f zcVqkUs%685(Ees5kHNgNAvIv$g*l$U7UBAO5*X+r+NNqPOP zM}!fp6siaEKn7HypBQ0R*$PlZ| z*~ib|12xG2QE0dR6E1U7$Vyp)YTrTmeArDSkHaI)Xndq|0dI_Ld(it}i!EQ9M^7Ep z*s#yG5>eTl`j>WWZU|_c%qA*a6E#E1G`~d}^M%u`6+!R<9lxjmyv`|H?z|r&LNd3EllQT`x)o_t0_@c%(!d%`1}LyhlkzW6C~4Y|3NTLifh5+j6A;qN80*U?}x zVqAa9&sN90@>^jC5aIWREQQkB!ixq1Rt9%-v;`k(HzaH+?9a@iulsK4Mwjtpo$>z7 ztreDGh3Xl`hq0e&JyaCImc$jHyC1;Sv4IbD4MD&+(nxbzsgvi=eJmdY9UocXy{UEin&9xP%T4>7gR21$ZNqwWXbI5$cxwGHSQ zq+pnYKK$Amnm4~!7*S9R-&;3@2-`IeTE!0UfNs8Zp*u5Jpv@5pHx%7zr2=_pP_?2DGd-~J^9`Be z>eg7AmRU+}<4lC);9k$9C8hBRaKjv!U;FGNDu-BH^w$X394uYjpx>;-9d%9iS*$VR z{8k!?!_|3&JaLzW^wOy2eITi0Q%EJ$m%=KXH{Y`K=Vjt&qr8NBdtl!Dgl-$P9Gn>NkbXlB%{*!KvWQ9!+Fp=~C87@WJVBIl!je?E}HSYP?7TWX<4uP-8$ zBS4u9d22Nx(#g;N7|I$kjX_*;xf4Ve%>1)DRZ_kxw9Rtm0bC7oXh2yPIYlB`UsU{I(hLZlv1WZ#Lk*AqQ= z-L-sgY7FV9>=F}-D`)5f3?jzkQGM4dyDYRv!bcM^r|XN`jJP)#S3ZxrtL!Ck)^^^E zu^V0y-M4raw+6c^UAb&GU$sZS!aU+%C0^OJlQ7_?-bb@ib9YCyOL3XX&ud{XE`CEw zM~7n|3)SzbW^(Oy6HLoEH$p5>Z~Xd9;R{3Q7In66`bu6LB6nQnbq(NCWe^P@!-#G> zU5%01(#nI+wa0iGkR&P|Tx(k!%y4CNuH<41ufcpPvq-&@jDU zeo0ocJa|Xt=v5fZwn_sN6EK8Op&O)|?p~@l4YYSi5496r>GBr+ayF`?k&e2JmPg-( zjOYWxV^era?3kKf+0C>M#P~8g@^H2YR50_isoseJ0_o@I`GXFbD~75@UY+7osp>+b zLH35&BdddQQhFvMqvM$!8+`4Vp>c<)E`3CoaJ7g5RsEizT~YAy0i(-(?_&i*X&PzA z9o|$~B|2tSjMsk0(F*x(7jCC`baq}!J zpC<$(vF8Zt%)sqv-R_UZvC`XbtHSa52Q=)fNB}@;8irRa`4P?l^x>xu$%>JpQg$)1 zHaDnyUa(M)kpcm8pL+56{nx^zeWgi8>te6eA;#CFy%+>Kq9$n-jPlCpa#6%Lvy zkBbUPM1EaCB^4D?vc>J1Q~UJ2Vl{0IL(E%-$YIb8LrJh@cF#&WFK;Sd#v^-2;JFY^Ig9@>+_foS6B*+gyv_3X6DJrH%g@-EjI32bCWZq$ncYsX z$b)%?rhUw5mmN#j?vBN`hN=~#7^%LSCo>4EJjmKG-|0%LPU9uGx)za#GgOoUAO-ha zqXW}Q;fTMQMCG2HJ^EbT80b;`8@C17$Lb)s&n@(^&@ipkh0RZ7%29M$K=D28T8Uhr z>XdcU<8a*s4-@p4!d@*a78ZG5xI%rN`$y;}9r~={V$X~$u}D2B8{2(T`lo5{i0i`c zoS`0(*}afZq%&EV?YLj)uD) z#`HSV0{d{AD<3Z6mh`wn!hH+o>UzZcC8sA+zpQd7D5caS@z=Tn{)3ro2q*X5f^krFPD0M?Bpj%GS9^S=!FW( z3J@k*C2G^SZh?;DbT3UcDb#xI`~D{UvA-{!>~8=80tns$z@QgvzF>dI38_1rPo81A zufZ9|4;|{feKbGaHHH!85;4%aw#Rg2DLlpv6M=?jvgXS?>?y-M&)obJviM+z~;XAn*f$aa}Wv)b??TWV_E212Z=BROHdi zFEePZG4kNgCG^I8$fPtgo(Jt(jrr<%i@&vJ-+6jMhvGzA6lJ7YyMl(lRhhhNb zXt{7M4F$QN8xW&L4zFk%$qN)pW)uBP%pYQr;`9;cm4%o`Bu zsoP>n>{3TnhMj1u$Xud(rgmi?SMvN6l>)Y#lw6c8CqJvq^#(NayQOf2YOTr*+M|Yd zGvxR%WSa>#o5QMZC($MEP`9XMe(v$)VvqT-l|e&NnW^8KC>d~FqlLnBHRSOK4>`!5 za5IGiec%Iey8E3EI->qCgRvm*8U=J1R>`=pK8b8U^ON>?wkQ_2=Hdio>%Nh~&trJ# zys3Oy(#84J!OgtokbKj}=$?$jqXik97>am{*!s8U^%i@H1rU66!xh8`$AOaL&Wt=x ztaW3yc^vEUzaMYpP;^-|Z!Nj;^FsQ>UzUi7FNZnJjP)!xDFv4FIoze>lXMxxQe9>jdP5KhfpJ>t?rw8ElL}`2q*n>}PE3~mt?9Y@HY&|U@MvIu| z3}|Bgv;9evaNBG-A1@5!P2+)}6Gs?QP1OrqU3|V=--18oNLPBxlquO0OIYT|Uqgf4 zuEb#5btYqP%U~SG`Hhh7Vn<>bq@+{y_en>e8(`^lv|x9&DejHb6B`%`+;Ti?+4WC_ zq#ShB#>YvK&_#B+HGNfjQSGeEt%p(M@~;~A+R=(DTHem^KIP;XAJ-KD5`v3=TJHI! z)TmrS3n5{x!oRd_r}%$Wulc5bRIhPk1>ylh#Q%yudYaAjobc&q3; zb8MGZjjxQ-HGSHi^KL*|1E+)$EpTzdc*6+Y(zcz95M|haKV{EyN@OxQ6yz_*cTVcx z6s}nk0(VpBtp;JlWD!QMzCf^-jYa;93%f>~x@iu;4fv=gF?2Y?j&JWn~yAmqp$hLMM zD`cOU%ojGdyg#EIB?efJdpm~1_pG$zJqY6TI|NBKbM6910G%HYWVTFMr`6^(`uO(elw@BZ$^WLdO>-an-?i=ZR-n}(*ga$W|9xrOkzM}N5I)qZ ze_Mai$?x4Y<-h#dg7536hGpFZb~$gSa%r3|$gBzVx4pMsnn1W_JrUL>`0%owCK+0+ zQl0ZqnZ67=oc=Elr8y(t3RknM%GDGza}c0dl1{F0li*E@;3AJI1^ItuqVcjOLYo!_ z_onyrrLU`=qw}!2r}KBWAA@dj2l9vCD2=zf8?JqD$h*5>N;eJ%C_AW&0wI4*22K`3_LQO!cBcPrcpDRTG=S`0o3<88+}qk+{8fs5JL{Lv5%h=wCUBvWCeX1| z>oettzlXcR3tpmNi#jnuOA4l)eqxJj{NtqX(BwCm;P9|hzkloYw&k}A^mM|T1znYs z=b(T0v1M#dSuIJ(VjL=f|H=vr?jm35$Z`G=W8gIZatDWG0O91$`@Lf3pREP0+n_`r zH9FBvgZ;bbB9Cj%)1VwOM}quMQ~e_*0;NFDQYroL_$PhsJ>aOkJP& zHH#?V%Ua?Rfh`9EKx#bMLh|XwkN7T}Md)$32`m@kUt>t4_&x@#_48wRg8h9A8+5;o z!TVv&!vs!S?%BAd`3<=46-SJ)jR|cMm7LaJ-pu+EN1G)eG^tV90S>INhl<`Wl>q0O zhJxNcrbf8Veh^c<#B}$sDz+nhXJ4DI=1~86$CZ_8&(v}KSPL^S1ME}gQIh=MmN?5d z9(Qw>>rv%pul}+XZ;~42&REu`pDP3&32xy8gzGql@^(5D|MEw%v3aY|IF5ZYJm&>+ zyA7&Ko>d~y3%Eg$d!~Rqmc$qDdpKH|SvI?31~ub4&f!2$2UC3!c=XTgF>%Wg{#48BxT~pr^$U+U$c2ju@+6?MXf7$pQNaf| z;=AMF!DS>EJb65EO)5Dslq5b8aLZLG3!oXyU9j3u>3;4fZG2{$ za>MK(ngL9XR%q#g*?(nT5X~ITZb3RECdIJdx_5$e`Zthid``F0!(pg|b!V>1#YvuL z=Wc?1GI5IvotuSI5&LK$;E#;YmD=Ix#goVjf5cg@{F?)-d2;5&f%R01Vi0g(amDk* zFzNnS;Vk!PI1|+9kSxQC&YA5hWkLj6zuTnRsAkXGqz?7XlNkn)w~>&;lAF-FDlKKp z{ZT~$j!uYFPD#KekS_>g^t4tgS826BX8FCBxOy6}uekZaxpJ{I!A5@$y-yn}v~RI9T6^Ke93Ttf1srtC1w#C(+XF zhBnabG^pt(VfnUvpUCsoQ^dkx^TZbtV_mw%BQ>8mRlns!&FCz-vu*2|C-@yDgr?77 zrR@0lsF*ED)^^eurJJ% zJm*bv=Mq&_@Xt2lQB@Jz_cR0G%1m-Urvw7#EO~;Tfc&f(B zm#;Q{!976`twj6!a};6CeTq}ryq1ilKlS3yDnaimOCEZ9P{H_<=CD7l<{)*qRJhE4 zLKP^3OGqKpca*ABVoaNX8vz+0tHiwr`B?nq*x~#LdItM{P#l7DU{7!Ks zNsUG0n`kl|N>10QxE%-M3kyS!!*$K`trz*(z_hRipzxjt?3$scc>uN-zkM%F6Y|50 zn5D+A5S`Sb0&_<6A+rq~#k)xY^l3?g)Ph`81xJe)c_CJPV;W*Z$K!Z;$Oq_>10230 z|8n^LH)vXuA~IIGS-L9fQ=kWtra2@dboVZ9x3>JRdIdpVN3!Z*CH$+z2O4k%q_6zH zZZv^lZ?4bs#~9HYtg+Fq@J+w9K5*eemRiBiZT+*W>Hm|XwhYg0AjYc~f;C0-Ag&%# zIQ*pVe~6Vf-{mfKi-nu{WsOeJ*4vOSS~C2J93o^^>kH*BJ@c83>1@BO$KG?dtWMmr zUeBBVO(|*saGt{Z9h}L(gR{|Z;A~=$MRsfFHR<`D%lD+lC5Lr+)u)@|e-?;qxOH-t zkhVcsN(j&AFjY{7ZVIEcnR$L>W8G@w0--d{&tr$T1Rfw#;peZohx^hhPJ}<3y;A1U-MZKmI+`YVws<${(yhS%u4Djx~ONVMdf~ z+nfAX0&Rguv2;{sG*g?SnFEPaM4$=d95t5AvKsBEVwMO0ZDjPOxfAi^7$6=Esb@pu z4|wo>5?Ieq!ok%2?-^(?(>YK+Qp$W!zO+J9ZaiQn%Yc`+U$(Lnl>_g5deL|V@J(*x zr4)r9pI{~LFRYaK53#aaw?oCThA%{ZG)hD>mj_UOI#nFmb()1q1~0ePuF&L7FQXyDY+u`mda`j@;^JRJ=@gS^xf@1-Bmhn(|D zI!X4gCW=*Bhwti=8s$j}@A2PE;f2!vs}z1p>_pGW`(4lZ4^#M#8?RM{-8nKz&-F0= zk-^vG0vUYSj|{%-e^LhT=rOJYG#6er&o^$q4XyeZ-+?Oo!kpnV-7Ze#TVb$Dp z1+1E|B(d{m4SAiGXnc1UP}&_M9*jtAz`i{&%-j4Db@*BV_Rs!AJO!ZFu;ce$LtirE zMfk~4FL^LBmU;ok+P6LION5KGqy4?7KWO?De4uol!kZEjHSu!~m2<8M$=6&c=+{?y zy@CGJ!QX z6q%dbxffNY6=|4B!C#*eUWO$N74tI8*vrkmWx>8_AgAn9xwk`|O$Q=ZcH7alU+4}m zV_+Y;&Y~P5^)R~mZSZE#(jfT8snYb|52cCT)cehf@uc4SW(-HF2Rq{i2W>V#RGpiM=H0QHwv0n{Nu2SK9wiFY{65aZ0{*W&h zt%-mhL&(7^%J-mP%_(gDE|+3cCPFp6Hh(e;=$U&@BxA_=R_P$l6fQ^GB3}ih_y? z2!aZNNKxqs1Q7)3QluA=Ceox!Nf5E2G^tXfbg9y%Mv8O@9jOrmgpNRH34!kkE+H&k z=Y99y=NsQX=iC3RFtmTM&W)Fh$$sY@))2Z|yfI|WdS5Ey9E_916yFS8v9Mst#pp0^rV z)YBV=*q$3ha}*U%38&?@E$l!;NRB;>7nZ)Lzo{^Nx$PN%F%+;XD}~|iwd=PtC`me1 zyIWt*ZLogc{Nhqu^YE+T8@*D!Fpp4~QezoNFSqe}+}1n_>GI$oT(<3K>C;#jy20$3uKP2Jof3W5}<*^r%ApOm+9>66Q>b`6+mvzyr zb4AEhDA~_Gcij1TD+|Y-?m7vTf;T&HHQqS9Jg#mbImi&mG*svI%9|T zNf2d$J}c*@<;!mB$6LjV>dJkKXUFy&7&Fd$ypX{``X1fVEduH1KXW|{atiAoIXa!) z7vy;bwtPZSzRynB;ja6pP=O&)@1ff*a>nDB?n1+MpcZ6fq)1sH^nW!E8=#1$Mr}#) z7&?lw$juT4x+@?Da4$s@<}RN`;8h0AEvKrrLx3vX5-Z?obuMFJ)+^SgmnTNoiG7-_ zFqH)eCRv$`A5>mkmjg$gKzzJJR5VV>756(i8?1E0(PT+6^*~=9KH8zWwNikYcNgn@ zeTg_dm13p(0`ZJb-sWK)6wx${iF)dNub-P!56*ORP{_{&kG7JTI&Vv0;tg`Xo_N^% zIk%?0M8@xvi@6SXn7o>8qCFie#rAhV^GYs-}R&PI#Vfr><5 z9qGB$aGD3mfSGsE5ftu3zL;D?iNjJJ)c*T z6LDGfDGWwyHHHTx8I$54OP(2y*KjTj2 zg(xC;8~B%cf?*^h%A(6)|=_1@AWFkJlIhFR> z#L@WMv=6M=m@RL`n;twcTR=Ar#->-kEeYXW8<3ttD#tkx$Hw_zW@<0mR+K=wT*FMP zE?#S{GPwo;Hp%_X3R#6V3}ZE+q6<_oX|(g&N7zU-T>=Mm#FuWnr#)(*aT43gh>KrC zWEUhtD*7{~KD?{J=-AKILUcfXxe|FiLAGaA{x*q-PqFv5ps8+k@XndePBmaiP7Q64NdCklNO<$~q?;6Qri^9sYstG2ar(uGpEH+1&?r z6T&Y`8P$2t=|I;Ymtk?zHM52HjMuD{m(k1KPdwMFln2t{I93RXo)6k zZdd_8h!ht$-1MkCzx-4Xta$#1 zdSAM&OBofGAj!i4o|czVv)8;Yfvoj6Pw80%+`zAL%Y6=fcpq~+)Zw-jg|-&&pZ&s6 zSQ9KKm}>Vtk9Ymo^J~N7i0jH|!1?t4#&KSf=K-?4fBF#v+|0JXOO{zth?TyTap)uS zPl}6efy4~2dMbSqX1#y1-~V>1PwP*Xg+aLWJEbHY4O8ula{_N8&q#Xg8H%JahIPiy zls=C0vs$EWKBBlW8gF#?H}_$zFr|m~)&8dM_ILb_?`_DGEb{%9st%31%!qkibNWf^ z#k@mxTNsh1-GndMX0VFcdqjPn&`BMj&vX4ivWCC$(9>#>_81GA->4sq05=uF*%OQl zXd4T_Z3WE-I)rETx<%?vqiSHrwXFc|zN*^$P7Ev4<6)YS0Pfyd^qDiQ9{cRm3m+P1 zfUi;Wz^}ES(=4i0=!OA6fY`r)@vGi+MU>tHbehY^;u1D?6a9C+aSOPRZ@RPdb{RGI zLe#gn?68^q4MO!0ePtKkZLK-AkWqu{Epi;K{EUv8qwW*`lPfrR8jR1kHRt_r!N6sK zfPRdOS1IsVlMxlY7S_Sq-hz&`NovE;&@pA-rak5TNy>xj3(L2w8xLQUB{+S}V8O!9 z+W|GFM$q~Tq@KbUgdUKjXT3JrJJ%|%d9e7jYTDgdQwL))AJkauoEz6ET7*sqVWsKa z{Mg)FWYEZBjg4QJw7)+p>WV)D9fHyMp~7hi*UAx0cif?MAlpq5Wmv-D;~p4+C%2Kc z4|O|N>U8br+*dZv&dhcR>B&>G<>+c9J%GWLy(*$D?e}86DsJQjgS;$*F}nL_#|_fw zoMO{&c0W}qz{R>B6g$7Tx#O;QS+pE)KjJJUQ%^(W1SQFwMui5WufpTg-`uc%m>=&m ze|SKJJNfgRwTw`GpRQNJ8>x>xH&v>~05w5Kp_i!U>+WT?`pjWhnRDJGm^fh)Pxp0} zt5+WM)AM>F&*a5>4AH$eTx#bl`t{6Gl{7Eec|o| z9^BO0t3Fn>Z&$7hi+iu{uYY=_ZY}i&lsD9VCL{UKJa1CSs3Cm?c*%$I%7g=AmFdA# z*)_DYC(LLb138VCiHY?0Zn#qOt5D-rj&l3`lU$avq3q-bfz1p$uKY^8Grdq_Bt z98u0jqrR~^Owj;p2HA$1l~MY2WoTqMn|eCIZA%4xpG=>;p7D1U#Q3Bu#d7z5Wfqm3 zx+Po7{0G^Zy-=9cFG#chfM_Awit}Kv9#4I)I?Oa(SK=4CBCaS#xRvj}lQ3@4!JN}k zSU_RIl=eiTu+bkR;vd5LuAp7MSS(O7%4{ncv)Y_=b1oDWSQ))L4t)>N5*N$R2^sj+ ztB!oM=~Y*Hskhoekcm#+S|;W1h9YTp2r2=)1kbxziWoqacS3|2&qwvKCf&IQru=_r z!`67SKlN8xDpXm$x9v|y{uX^^_5*z;h~9xd`)z}B?+=Xv*A9(>BZu;&R`0I)K}H;UR_ z_c}|ua5nylb;R)Wp9W~rxSwdz+hW3**KK4N{rMU7_8ov$R@Z92IwbgWb@XsVZ)Dcc zl;~{?_#Q?S+wK}DB5rqH-Igs}{d7NMOIrbrfhd0gON?!X@D-#AqX9srwZtu?fh|xB zaebLZcxf$lFze;wyjeeaf!tAHZlg(Ek8NQ(GnK5su`Q z{rgkDwc2r z22z^77s~y;3b~6i+PEjV%hjsP7VFQ@sq{8Ky;#Avh#*o&Y+Skt(nqeGevhK{S$w`{ z7Mh?yuK6IOwWzhvJ*M2!{lz zpn*dPLYG862&=;kN1uu;8Aqs+Z}st95OhgO9f5MkEe*nw@N!1`vQ`FVLRa-CN2b61 zu&_&aQxWl@;Y56B)YP@Plz?>5kSir=$kiPxn=y8-Q+5kV5;!`$`(m}!wVgPdvRS)W z8kO4Xpo92q>&W94?)rysFpi^-EeAUx_mX}+g~2{+fM8qg#zw0cYYRo3?5|7ICsBV= zj*YnQzvH}@8_6$EbN)A97xXL%zwKFq)}fu+gKz(~uEIl_rBj&JsoN(zt&QyUCmnfi z?uuVE-WvZ!4cHGIo9EwjY(D=r9h+o!=&(!4aCXckBuP}m1F z_na47m+!6!lKwf!^Z(r-Pia$SbAeQZzWkJHQ;RpEL)z5MI_Bu^c+Gagsb09dbp$B4 z=b0~#{2h$_++ty@YcT`zaZ|U=?wE0`=>wS6m!;LuvzBqx%rhB@knU)J;COoBv%C8$ zGBJX@*X^)eF;Wo7w+)&-Rq;1cxtRx4ZhiTBv+3lybsK@NoXd0QJ>;CAn4?W0sTYzl zG9B7==x0hKcn#dEF&+lan)wTEQFHgUOZ@xykL9V)e;jHjvDL1h!#$P;rDZ(>0D5lA z!XvJRCOhUktJ*a54U`Sot!ddXD2k~P*=ZDF4W{JE|CdO&A@&_FnJWpUN28?9vPp|b z9rc zP^zE&DG7DVMud+>>E!LHaCu8|5oV-r1m_wr@bJ>)QU0IxgdX)N%huspAF+ zI`CkkY>Z{zIWd;p9uZ_L4J?_QeHM$F=V^T1u&BTX(JANadZgF z^Yr2Vo0#u8mib2(e-4xUjzeU7FgHiyw)N4X9>c}fSX$7WV-R{*9&pH4;!GTJk6o8w zv&ZNkxS|Ex8Nd0t5M|i<%BtD-q=giCw8p!Fcz@|ge=e^lWrjw^X*c#oQTdJe6Pu`r zqPdN3qeFuk8#C3RV)_S08>iPL%LcjZ+JlU;<2ciVOFxA3{6YP$DWA@(v66>he zSgT8yE-yFoKC#b=LTtF-3c8qp@w1#z(IfUVuDa`lPxHW^%5wLk=*q+F1MRAKctO)t zz@qlgCi-h!a9-DxIrE>+ugFQ8SfMBVnsAxsq2qSHqQ{9;NE;#*l1y#K=tm}7y@4^R zH?4`^7`(SxY7n7`moDP|fhW*2JLXE8BIgelnWTS57L^{e72*&MLWU5bV&Qb z*X?zDfL!axiX_!jP+ZUedWsPa67;Bb$8dlhXq9SD+sPK5C#7uk^noU~IP{bF$XM2H ztaX%H29reFfty(AYg{j-n_DcD8GVN6)iXk4gt|#})+kB)J3_cd_g7R6x9?s#6a5JE zJcnZ+8kcp(LTD<5a&^@dxp`TIF<JlCT9WUK33lA+03) zI!6JPnD6(VPW?@7``#tt2-I}rTh;ngS&n`2Q~_iDk93dwPZ{JUFWYktdIpEYv3-iR zysx_bqrl%$YzqxRr<_8DhANl613#4#9aV_MbOWnmdVmB2slsn+(qcf8uuwA#0{nW+ zZ^gN3V$JdV@smk2rkjy8|LDB*3tC*);hQ&5zubjsPW5;m=L19c+MVLVr+e$x{hHfS z74lNYLKF z^ld>tkgiexuG~NdChG`S80ua&owvIABdFz{otU?IwQ@pZGLgo&omq})$|HW!tTp8~6B*kCqM<}%hoQvfw>xv6A3Jla5mAjx2iyv<+tkZzQ7 z+(m;wzD)3>Ut6WP2716rGdmWJCa5>lN4-1GMYu8r4*I71=t=cdGZ%dxcP55 zVH;`?=j4U^I^emMRT40{Cod`U`A9GBV;%HhlnLl6l|aJ99FByye#k!s9U0qLB6==G z2RL7CzHflJ=Z~1g3J|<+}c8k5v-#i%3=AE!wH=a2u!CHtv=62`$ zl~XjH*KYV{u$FnN_Dy=1n4Lo;e(6+e)pIaDB^1F*pRB)~q#+~5Dz{cdHM=`;jEAen z?5<~FfX|^i4D?gl(h=XigJimWNtts>$0ZJGjg|9u25jlBpuWh|cSPv^w;0Q*LSneo z&pCG=o@33gf}x>bIDx3fhg#=YDRs#hW)$7lJrh(%UY|zlz$X>XCkogqW+e21m{BU z4O~dd?|ey=b|`9rx=vut37sMpoY%t zt**?&75J#>Lvfor6d$VQ>4gz`!QbZi{eJ}&;DfUKud`*`zs7|?SGce5@R9zX0~LTQ z)RW`VW@byjT2af{8B+nv8C1B2Q>c6GJs3FXv&O-jwn1k}76Lc2ki$zDBshoO=n z3!>vR{!la}*BG^XMnaxnTcE-!*b6nsXvlqyY9-A^uvQaO{Ua86;!#jfMR;M@W$qtU$DoV|+&~U6b zw>y`0cYm3%tDV<7A_P;){k0Q|0rRCc{x*h;^R{g#a8r96vbD=yG$&CI_5?7g~AGzk1b)NQodZ6?Ee5HaWTP^WSy%p z>+hQ~RT5-_-hNZ%QauT{Bn_n#~JfKLlV43)X$Hp><#$yl6a7shty2ycr* z+A_7i9~7Cs+lw|IWS0I~0;FmZn9t5c%H6PD@6&udpEp&IK!VG>cTePYLwUTLc_sJ| zAsrH<7(G7~HsVJ+xdXAs01$gjy`A^kZGr>LNA6A7vPMQ|lBl<97Yx~^1AEb03UAoH z|B4|j5^%z|`YYl+2j2`**37wa*dg2R2T2qixQ>-RQs!N5FtA>gSu^;_iLmTH%Qu<1 zapTgpW&OF;yN`24c7Jv*>6)z63rN^-(t|!TYlrG!IuD&$+~1aRNU-4eG5!lGJWro2 z_xU;j-!_dcJ_=eog84+xb}-by+kx)0MmkQ=a1cUW+K|nE;*8lh?lV6G_laNn1t_sb z4Kb?+5OH(DFkQrav#&~M*?hI{*6@>TA(NdP2O^?W)(v`eR2dDeHJrY*pcjbp8hAPg z!5A`osgf||o_MiyYlm?s!!a=z#AXC#Z#3%4L7xD~o&`|UX#+)_E-^P_DD0+k%EHpE ziLkP%veUVVNWnOR*bokzSMec#VuUVWPS-Xc4;-|)1VRvK8yC22>Se<x+6H7YMU`1UiU zInsW4b{UAQ&{4`!8}gdi5!{_J58dzKY7P33d=Z-+-ra!%N z8Y9RK-@^_W3lomQ(bFwZkg+8-NM=E7%y|A3zL-@a7<=jOMwmoLy8VCNPk`mG@IOndE?Ru7bJuSP5v z!-Jpob0h(B&Q?+rB95et?_0e$`6Eg$`9&}HeDk4H4l4M@%1PK7AG@n5J#Q&ijw z(f&(kMobYI^@LgW@QD53#7)w_N)Jg864fMG!y6G99Aj}n=(g%%Vxs_VDpc_`;KMvL zx-C={;?iRmwod_hJXgz?hg3QY`YnAWijWr*6Su=Pp$Gl7|}Kp{t;QviR6b*{%!kX$hP3T3xp- zH&c1vC$=6R!|+yaBFKEqwzWWY+}_9cXwMG1tB52@MfiaRl`GEaxe+=PZ79+~Cu~odPpFd7Z4aA_6m@ z*ijzjeEN)-4|?{*UMHqaEm}F>y_e=MgyWb^e29jh_IN)Vxq91Zr8f1(a{?kdDw{9@ z+Kz7z3*zZVtTM_~_u~-q2brx2E`FBqi4)p|b*9$nv)xGViE(Y2&o0<&q z>xr+$PkEyzAImfSz~lXV#Y{#{Cux6AD{D75c23aT6&Pk6_a z7r?zku;*3}F5!ozkqmA*?)!`tfbS7yFKxeG%nL4I+*Qw1=@uhtI3&ueU5UqMN%z`g z2H`&zP2}zN-G7C<$07D1I3X;aGR=gTqM>4Uwfbvcpj~iIq3bTF)B5LWs*7_p@1oy= zj_XLp8{>7*aXr-_x(_$>$`@wk7pmR( zcgHU~xXoD>Dw#dX6oW_I=8QJmC$HMH6$X~w&|c6ZS?csLN14xJ!1g3wY^G3*0{e7U<#HfNE%3hFTL2GSD1NOD#-qH{C7umKb;W!sbUS%6j!EU97FJdnu z%+%gCS3Qn--5Ypzm2dCO@V0OtGB0E;-scSQ4J!<>V6KI4<@R`_mFZ3B zU*I(If@IF$qZcjxEONaJ~BUH2Y2O>O8}%!>)hCmpNR9C0RYBc~|QX?zs<0N8A6 zq)xG9>}PQ@5Lk&hxZ*B#vKCX+II{QP|E_qzESdg{0&m%j0*8leMS)we%ybR&{3bcZ zps_n_!!lxZXvwgBP`x(>f{rJ`B$O1V>DE!^xz7&NW}dxPAF9aA&_%{_;J&f{B_rL< zSeB3-u`C8W$^trxK627}APnZ`ulCi#r3&P6R@t6mdB@o8X;xEucyi?FlQkpo3=jwY z^ICsir5>VwNtIw}_wFi52Tq@n3Bz0N9<&^hZDG#?t zl8J8=?K8?JU8r3rc$jCJ!6Z%V=Oir+9&OgsVieB2%+m>QrZN6pK~L7t3gfO!h<#+` zZ6$kG$jt5G$XA|O^KnzOcLE_CWZf;Xd~>0A?A=TacDK!GHp~S0@5o=7$~?;JpO?LX z;Ysrkzj>5*p;mqtrmFuC^mv5axu8O=)FQ_AO?XhzZ6Q79c-7+3?W7AA7x`ga0pt8E zv;SgYbd|GU{TOC;>><={&{g;x^@6_r%9popIpOiKaXwSGWD%a>OY~d_M;aTa6~^GA zf>Ml~#Jc|ckiM_m8bn|jRmHRLq8{XI&r>f@-v0GR{ogGr=F)BITOi!#{pdOB(R06# zsL92sJRSd_ukFTe&2ATXW;xmh-bX`Ye_!5GE5)J8#43L(CF0nn{A=Blvrlp9A|pU?e|(=-0+fzW1=P-*%O+Js-+V`);4sFkvp(s(=(Lx=x17UzEbku6C`J2o1aQ4yhi%qV@!S^{^I|M!+*oDWO9$KzXhF-DZ8$Iu8 z5Lw{EQDWu?Tg5HVmhzb6EiG25p7_kZAMW13gAh{ZP!W#fZmDXnQo1@7Iv01(aNdHS zp*VzjT*h-{|scHVOGZku)IfeUuFiaKI;u7aGJ_-2= z+1kM+R462Fmopc|m)*b+)n@;ox#MdMe6Hh6=?_L32ue-VZYe0Ly>gM?X6N#WBI~r} zMiqCNju1jvoH-tk_1Gv3%lF(d&u)mk0b|LZb#i>>c${}cAcVM33sI4&VL=+^)xFSd=TK(5 zYKuiY98fhNBvg&tmtVR9%nf_B+Tum-imN8jf644%ROkrCuHt-NHG~Vkja33?l5H$! zn-LTZkrPMtX3?V056gosNM)fQX2s=XGh?dpaRM>;)G^wSI?kADW{Dy-l;)|s?$=ian8l0ZCTtF$hMTRO?4mrJB z2LL%P;`f~bw@fh^DUPE&yz>5m7dcuxW}6XN#tM4yOk{3_kMu4_C}4&}7eThbH2}wF zM}G^|%fHTibVR6~jzkV$e|Cw;@Vlj$MP&HB$LG*W@c+;xcx7E*ID;P#h$>2dDj}fjDl`#Dn|)C7U36NL@J4LD}Uva;LPEY|LmQZ6u0*Zk_E9*oBR>3dPm zh8m@Bl9zyFoaf$ZMFMZy(nHDZ1O%;C2PTzGEXRko7*%!*YJnp15XdI3a{eyDy zd(+eF=OXQzsi}M9&yEw8Vh8Nt_)-zVnezGlIEU$MXUZ-v9v^i9G2Nq4V?lWh0$Fvv zCaHkrN{B69Bn}Ug1gqG!j8AR(1ly2^V+i%n=LQBL=wt3I6mOP^NM?@qZCVakOR6p# zrXrKMM6bx+12lkr-j<00SeRR@b)i38?t2P55h2^jx@5;|a`T71_(oQpzT)OlM+ZR? z>g(Snq2eg%G;{j;%yeHPrFZkZ%jK>Yws77yshLH4tjANR)QW@g;o~h)eoyz(oTP#w z`28h+ih8v>1qU25(SeYyCqsMpf!@o58TdK;r@J94){qa{2|uf8&{kJE z?gWM*QIo&~)=?7%xF6Ut5eu%LPU~5e2P9c0q|IKM-|_u6I^jG{Yiy~2^5Ijc4ZvAR zu2~dM=Zlw(L{fL>gp1ctPT%-A0@=-Tj{&CNmuDb1@}Z=}98P_BTxn}vK|Mi;oPiR) zL~NXH&Vnp6pokHsk;AD1NisZQH`#y3Ah#XN)ZT^GRokJ`yw9PPV-x_Ewd=mpyA~b; z?cBe$7?vC`P6bQhF!T&aKKP%7@c*@iQ1SoQ3*qWNEQIM-bO*(>2b?8JOGNX#@NQTQBf1<$S<@S?J;0^WiICKOG3$c+IM_4lRaO?;Vu~G3<*?P0qXL7fvpZKL$BS zl17HmGdBL9r)w(5h{%U0)Y|Z$7G*PQ;vw7WqSw@idwc(3fqzZ!;CA9@+H?}|r)l+( zR>d2yZ`|7Cw%@+BEp3W`L?rV)YZwnSnOF)n%kDSRb!e`7?$EkAlh#){-GNNylwcY` z&|TyD0J$W;dEa(qI|Lnir2sF6Zn76dbdUO;Vx2V%L3 zo7~X#N4i6Kg%^<>f;ztCHGFY-<(8ka_?e73^DaI+-ulQ*{D) zMk%r9^R|u~*7pWaK>1}#-c=0>2$6rwAvf9v}%{ZF~YizvPkngP+M@E*|%4c znPF+K{en!2Ky66HO*T5c_dX;hh-G``iBZ`Q+toKU1!qq;e+Kevd)xIJE8*WH*&?If zE0X+aA@NV2eYRZ<+wrFl{iu)Wyhd9FVtmupjX&|J0l~h8MV)xlChxrpmI|R~DX?19 z83gv~GAWyL&F$(wzM!d#G5^`sUGyvw1+$R|PUzYf+jtt4`s>muXGv^yYeqw;h}lb? z#2nDTWzDL(qrOPFmty44-kzkGNV^if9_7_yFb^-i6*M#X)IYQFCkNh)FeTCu!_dH7 z2!GG=GYgzDTKU7Y@&+39gavn*H%xLgGlOMiktS@j82#pKR?X`=#xTC&8|p}m14nPh zfusL7#DTx^)|glx*IBnJhOQ0JxuD{0ZuqT?^5ZN`1Lj@bj#?KYKOKsAURuD9U2>qT zZ;D)6{SvUwymdtsRvLB>b^E8UqNq<#+Ru`gRVqs%WXfFaW%(Dpz=HaB?fX776-5mi8OiG3ZS*fgNLcCy9$zuB&5__^QT- z%(uFUH`Mz{(h~Drjpu5*6#t$jnZ*>({Tfp8}GboeV*lYj+~`#Z59?M#XkfqPhZiZIA)P);EPhyt2>(=l7g!K$g1B z%r|F4WTG=|&bFLFXusYTh)lbjMZ|HlMisue7FXZa_qjkr%W9mb4wu7PBIlo90?jJl zv}kYYNTb5^%Ql!PI6`@YG%+sJpDM4X-J9?i6ZFzMrFCVnNbyX1}}fW zH1Cw!SixZw53+e2J}7nQm}w$nXoPr8K9xT8^n#vyee+JgW?v0b=waSTXuQANOpvc= zth(`5t!nOO@B)N;Q$@J3YH0I|Hhm0gj&LFA-u@{@cz)6X^>vvY^}bIhrp^v-dtQu@ zvyCUY)Ihz&A_+#!_*UiOF@K^F-Uh076t~Q*@@cWc!?(}+i@q7{yjMW#; zeOB4KR978yeuRKjR!1p|3sdvpeG40t#tJ%a7Fsc%u;gDwSqg-F$%Y%tPW2%rtW&6t zmX6;Iw^Nfx1zU)aJif;ycRr3W z`66ISYh`euTb8s>^P#}OMEn%gN!+!>&DO-GF3?Bw`7NL<8Yy`l<$>4(tsHC%zwvPM z__rVaa{L~hUeFAPLROVK?LHg!x_MA#yUv;Ae18(lQCW7S;U4~ap?U=g;nk}&frq?p zEN3%XoX1UWhs5tksyNqgQ^jMwT`j~*VMUXZK5lRWuQCgZ&~)T2DTHk+go@GiSsaR+ z>8S2`02T~gg~8x*j&|jN-@*EsuM+&X^%GO{LC_CUEC?BtDg1!k83F9#KUhpm4)I{tZ79 zUdX4)03GJ6n z)^J<9B4}CEtla7`zE*9fyyFk}EkE=)otw*pw8;3dQyJOhvhR&lF)dcf+QLBEU8Zc6 z?+6yPY2@b8as;rK?NKr=YgB$NJ~+BrO=&C5gud|rFBM-U2At#u#Q~a6Bo`T$R(MN< z%_NDuGiY0XXa5-Viod+bV>l4@V8 z&EOMizEfndJC9{+EKf0dvSt@jJ%BN^UBoOM7ykqj0TF$wjaT5>?;~^l%-J;g{aOp+ z5jo<+&qHb4 zp}UQyP(+(!3@TbHe{!BHXjI6e6FTtV>*32hc2RiBl0Qvv?#nOd1()T1nygrJ)CFUO zJGp88_EX-g@5O1qy!ep+s5N^gRFZE&75ilkyID-<3rtjyrY7~Dq~6pShW^xkz+YC4wr zEz5n3&g{QeIzV}-Kz#6hySI6FFGci6bw-w>-Mvo3hP_V<@OhD5qrQA?$+-`1*0uI; z9D!@yrDNLq#Ue&khLR2iujJ*|w0FoTzOQuIe2W5p)cLtC@D@L$#UWI)l~a`>mFdB^jend=AP0TP4omtf;V*N z&$$ivh3&3Pf9o3%eM9DFcey(Wv48Fp8wIU;1Q!{_gIdc2XEzKO^ZSfG>1+42)#!Xv zo%>YZ#jS)~y5r>VrvDHbMm9>KP;lg-3rjs>rL45*j5DF7DF3oc=IkZds6N``c>-`2 zKXG(}dR(yIOS`RQ@UCuL-}3_K7a!cjw@-1VO`~flW*)ZJU+;f*p5#UM*EC}jtC4+XDyG#&o~I1JC`=V? zmiPP~$1QXwc#YqeXv4PbY0Kk?)&0#+g`V5l*3Zq$2YXPa=&s+(M8+Q)S&~)&oOt>( zsiKlboU#TKd7ulm!m74M6qGm4Y1t)J_cNGGX{KqI|lrrqDXu2 zpUalIKMEI{!hC;5fsb_iL@$U)7X}p@+SPvA_k<1iYW1vhrRE!dEj;)sh|N4Z(4OMn znov+^liAYSW)_9RgYJ2_b@*_!&!TCCY*##$-}$z;!}N?puF~u3VY0K2KU*3e| zpL?DQ%;{c_+^PKYG4M6Nwf+U{tVT`tC8VVJx5CAc4Ra|E?Xga}r|+eyHfB5cy1z6+ z4-YBlI~;5MR5siN&eGTn_D$#sXVtYSg}{ulwLG1qv5v^SOI+C_er8y!6vK%myxd+69iymq}uYBJPan9j&_VWHTf*&J>lKBWW487)Q3&9I| z+=-H=tZy@(+0m0Q5Uloa=Qpnq(caVC;g$8YCnR(S*gW`MYBo-czct+35Dgk zY^VrD#f#qT7FjsfE4r1iEj&`7;f%>(e2o!kv4nOAFPoGLyPIIivwNl&edB_wf&WvV z^I5`SdrST}hYqWTea7ujf)x6^#{P?m;xjs1ao=Q{ao>Vj@lE&RN+E`)>HUw5vj1fs zJv7Sn9;7QIXU|sTxx9SuBV7GcpZ(__M0}}`G>17)Tkj-QSN7b6cW;{5H)F|-FJo>J zJ+>i2(o-pd=2|*`C4@Wc?@S1fnp{_s`sN6&&=x?JzCB*NY0s^@qZl}At;{`CFE5ze zcLmM9TGdf?xxK@=5jO)Fb+KVcGrFNj#(cLXkRBQSk%`B2h!?CK49(;pS=+B0+cfXL z;ud)FCOLci^_jHG%Y=rjdV{`g#I1cYgl(jk-M2poPp{kHdilvn>ETx|jZ8i(H-6UI z<2riHfCjVFj1FC<*TLM?!AC3W+1^QgNDZz{`8C@+NnhUjgdbqn3Tn^dapZWt@Ai_n zT;WyO!P?aZ%z z`56R0Lcg&G{NIm8E}5xsC&%>mL9}6F>3pjn_MZh?^=#bH$c<7~?1(GojDZK__UsjN z1qg;qDN#sIZmUSsiz(adt?ep^P_jojB0K|%6U9AL7euMPavlr2N}-Cp8>%TnCUq{k z)j(-@s>)&Ag&bGmGGNtRWo>aa2^E>U!P^uQ@%NoS%(`giYJI5{xg#y^hRt_ZtK#h z9+%g_TRR>fWM_dU8 z_W%|m0nTLIxI{O_%6;?(ypvT}y-`wul%N0On^N=ZA18W@o%FX<2*AV~rkjU?POK6( z#FE~wTAaq-BnU)s=*~9|=VxdD>o(KTjxlmp$B8S`7;-~h47~C!;!XE}lfqQusD5PE zI3jc7VV{MWZ#13!BtgRHZi5P5_*-_wx|e91Wsrpf9%oF=)!ukYi0bn@$NeVQ@LSDv zb*q@?;Ka8{^9TL-I6PlIT^g~p zyVrfQyWm}C>r`}0l%#pV`r`aVUf;~ngDY!OhE}NHOwB153Otn6a227?^XJyU$fbR{2z}T948EW3K(zD=m zBbE-czT4&%?F99geeJ{qoKvZUH9`B>fRTd1F*Lo~UD*8(26vb$B2cbWU2?Gzt89o9 zk??h5x_MrHI1G(N(LQ(WQ$!F8E)WCr05D3aZE0X6ibY&|-qudG2vmd#CeTp+5qe`yf^w@U}y$(4;%P<8mQ z#wa{-hrgKU^;PD|QI`AKk3UNaKvF}f{PY)x{LWwOC-t5yh=03NOi3p?7exvp- z^UWhgb#@0ER=Lt8l}OTdDHQmlwN<9Bi<>*w=`pl|Tn<_qwDY^6DxzhVwfgy{9gA3+ zljVIEw}nO1@e`fI^Fwd1qL7DUKnc>~GN;#Tl6%@E%<0{md zl27xS4q~9@9g`10sFq*6`|MFXtjW&|lAYd|!V0HK2f2)%@m{5JTi(bsdnd(ORM z+;Q(e85twlYwf+(n(dj-o)coK`(B!7GMTUB4QQsJ4=yb%y;98B^`<6vS?5Vgo9%D9@98Y@FP50^;H0wD^&XAVZbziAul3=g7AsNp1n%?4^1=R?d zA?r~H6fZvV#Oz{g#2>0+O80Z5^quW55L4LQ|3UM0zjXX(ugaYN)VTNm9rCwova$t3 zDCr1D`TGkF9^63jUiA7Gye;2;;oF9=y?Tj^zt>Cr|4_3lMyBFVYT{Up%}s*`Zpg-0 zi~}#06qApl9`pe2|B1DAOxe%|lPjni`x4NBCo-5ztIY$V5B}DQ&6XcgB~_ICx!4-= z8jMPKlQg1NVj86NZ{yi@V6Qkw_cYk#s)1;G0+ zZGMOMV}JC>>iTPsEUqgVTvJXL(YqW+L7mks2-)b*d{=?j2S3AUM9p?i%%lPoX`p_j z1hSl;Uih~;_xo}!mfyF~jRJaeypujNx-r}nevSgLYAHhFK}AB_Y;IvCVHv^A_PCScvZ&>gV+aId3|Ta5GA zf-JA6Mgn-oSG96}Bh6Fneb=Ugcg9}j5ChNs@*5-R`j0#`&`nnoBAvmFN7@E8u)S;4qvMv}^V2uUb)qWtmC}T1w4zTq}FJIN2$lT%sW_?c> z2RcAK`VK!2L&m^fIUkk#K3%4PG`_^TiLTe**$Vj-LSZG(@D}d#r0Y@_tjW8^Mta^A zeVjCEs0VBoHFMta+$7z`XRB5sJiJ+cEwZ@26vkMltY|UfvL!0|;b(_}&+z5DV9inu z#GBkpBuc%$q?xe4ghT-^0fLmK?`kS-YSU6dOz>n9ZoVyJ%7v`tDZ`HL$*A=-)Bj>T35nTFo^bh*aNy6T@o% zRatBQP}XICSJo=yS3hq8MFjPUiU_t{rWFTfE10NP>H1AKLxH&Wip#sdmBBLqF^`zg zUyZ{5VxE-0%|riVo-+Qw&ZErnB%N{BtQzHdi%Sz?#pKAfD>q?yj%SzgiE#ls#c19`(^N#?+D<=NF$_;QF4kMeKv08qDwr|)&wd~6#~hIc3Z zf6%7>|LN|Iozv-B8-{&KM8zn+eEDBC{dfmYyZW-31e3h?`h~dIjC3T6*SmH1$NzsR zs~#eA+%$s`@_xsIud8ao=tjuA+*T^w$2MoSlQ41wi*xYyi0qgY5d=2}O<+ zHryilt+bjbgQWrUp!&DL5}DRqTQv=J3@@@kk>?Mf=w10G^QV~??YeIMPAda*9q5@k zR@-Vd*7l(56|n;a2&u)D=7H76M-zl9etX$zu8Jm5MsKg^RTceX;tr!fLPc@aU!mge zAB|G~FNBJXH;F>UkfgtciVqfjWh6-wv$X6g9Dyhv6^j#L zyuVxgZx36|Ep{mKRbZ>G&9tb z;8pXy25RH7owjkWWej+m$@3>wdH_Dt6i^W{hk;r(ZrYB7=H_W|0q^&7Q1q5XxWqU? zrKS5WxFmdNbTGW|{48XkNDcI^w?p{TeK?5l;T~qjsZ^h~(xq9W2V6pUBrUv7=`Z+#4=Kxf2TRsN1tvUr%ky>gtvK@P+*Gxxp0kA_u@(m@p!lO}3S!gtwRrq5 zpbixJAJANvTY>?4l?^H|(QkN*xKr!-fABKAcNI8NXA7|=&4ID+x&9q(cKkKk{0~qr z5S?{lUpsT{HtA^v%o(G9@9F#>0OZ*h!Sws=vqX9#_SsPS+8{>831HFBoD%Wsyc;f) zbooJBOslm%71y4l2OtV+b6<=lcB|N5ZsHtL;v8YkF(yXlkk~yO+d4}@xbV*>mu?#8 z%$R*HJnu@M`6|}pPYvZ;J{#7_@STUpKzt|p4TH87hr=qYQx*%dLOH3GkcE}s&MM70 zFWw(X+=mKpkn_;WAv|B1EwUwZuE61!(NGqLzDdo&mqlos(9$C=UGje^f>-6IF?o=# z;&YW_Rj;*Y`bS~n-2l``TXEWPzV*0oeHqx}nANj$qF0Y=?fL9HM|RvYJy%Y?iuo^b zTtZf|x37HD;PyNYeFT&IHoInG(h(@!fdZr15thL~{lV)6batjo?`=fG`nma9Bl`P7 zZMBby2#9xCX>*JGqEJt>a-A$*f1Mfu4Sy}H`md^*&2d7F;W3Qn8A88Pz)l4WV)O3a zgeeciavaI}Jy>5gRt={KQ@auL@5Xg*)>k|MZdoz9bLCn4 zNj^JIgbbTO+iV-BGrS1+RoQIocPO!4m!_1Fl3qSDAfpE4K%6NyD^cD~V}p!qXNFPv zj$?~F^2FsOB@=-1l6RbtF5&^}_8CRc`VXDfm};s&(6`S|XqI9lr^PxgtHs-*oD zW$Jwpar`lW$-21xj>+c!#AHqXhRIGCu@)cdV!BM!bY$`Ry3pbC*aswHvAhYf?Pvak znL4L#KOn!?hQ5i|Q9TKbt91V3aGdK>+?D_W;HQZl&Rf@ee&eb_UjPn4#mvEc3mv)m zjkpbyr$`t2d;d<8)EB2ch-OGd_GM(AcC+D8Xfkb(@Bt!~OEbZfxF6*ukKH6LFM0gL z|GvDWV)gIkCBOYQaV%dVEYZPr5!qieV*og33G&$o%KrHB4dc>set3=?5LubBLSvj#FRP`((%;UuWn}S4cfK2nwT6PKysasW=$wm!w!y?nF0XB4w5v zTYiU)5YD;IQK8o0+ig<5NcOSSeb^c`hkfF8eE^H7=k4a0{xX!Q_T{nZD{5gh*=ELK zoEcabiLKz<9ld@IWa(V|4bvl2hA~)mVvC9(g(5oasdY|RnH_;fVc->s;HA@&h)td@ zLl2y0pY*17zTge=_;sd-8Qo4ee8PIiKuT-$N~Iora9*!OH|LxcZ{?^RoFDF_>*}u- zg@(RKZ0H-_$Q%JP7+8LugZ6^^P_EXX`m3>S(nCzjFOV}m1#S5ypiNYG=f~x=%NlfM zQ7>jc=5-}?)aW)~B!zPMJjNFu2FEgIBJq?TS*x3TLcV4jo_Nf&O=W}=6uzHsr)Q&ON-wer6j8{UlAHZQ2 zs6;$7UhKS@1s{RgfH~O9{aGS{z9`}@;1_UnlkQK8O+p(6y`-g(molRuB~sc<;70Bq z*|sdDG{(%yEe~{7ve+#N`+7tQ)GKT{B%9q*LvMh^q&T{IVIrghnx$k8tGhnda^*^R zWSwkFmXZ(S$B8Y-Q8ed<9dHX}vu_{cDt5h+X%OFpgyOvQ1p4HCNWN>6iF|;rl$4?_~1haFjxZL{`>kx3(N`V@;-L z$)Fra)N_Jvjf%lBJ}48OYVHa&9lx;38$@|A)$7FGb|@XATeN-abp}@fiG4ZA2GzK7 zn|?Wbs~TQf#{AN(tf$?*Np*RQ^HPFK!!30Jtnyx}cZ5#p4RNj3<>UcF>D5(UJ&{{m zviRa+>jBQOj2rR=)SyepKfKr)!}A`e@)Y~hVIa}<;%YJ_(M?J~BvcZ}WUv#dNJ?O5 z@>-H8!)HP+T&(fq3xA!^K-Hx@cL6F$5V^%Xz&M~f?``8~;xgI#W9>aW@E2c5R15SE?1nhcL#1@Q2ix%HGpns^)nREG zN~Pz3=QcW5tg_kzqkszpmac zUCjN|+MBb4UJ0`9k8&9s)t+ddyy&uwUh>j#S>{={EnGyFkJk`93Bx<9EFk1pcq4ii zbrNRdCB{@$d|GRIu1eov4dVlxUHjK70m;3DYU)HpPRCDPw}V}yf!#}Ri4d`qbSSe|nqg10Pi9Op`NzyjET9B4s~ z3FKRn-i&%ANRI~GNICx8Qzx`V^ky}zi|O4iEQ{y<=I6=0@o9f_lztzoq9jGfA-C4a zlFYAvPhVFkd+6u(B~ZT1$x=cnLaJAtSJw-t${#OtYXwl=Hj`$Xx__}5lY1XjOs~IU z@OZw6_m~()x3uV_NERUYD}(V)$giOkPqUhj)EbrAneauo5UGpZqv(tc`zo=K?5C?C z*0*>b*6(e9ZnaLSKBW0Ti@Vi<%g)CoH|ztlPBNu+xGS{f-wZ(|=RqIyl{Ou(x7;qf zy@3vV4(qCnDI|O@e!%H1Z&mPMlXN((ItNBSEL2;-tP@?CDDBas@RyrqL)%}jYfhe^ zKVdT<8TN0v+AX}0&h*sEztYQtw?OO zj<(0MN++yYnffR9Ch7Et@d(smtK_TVi%n+5MD`4#flwb7x?)gboygU5hZZ^v?O|;^ z_ox+&>!^u?rR{5tk9^Q-=uXYjG?gMf>?{GBGoRa$K0e+z9yD~(Y5xoZpKD0*O-Ck2 zW0|I%%&nQR3D7jy&-YI5#)^(3F3vNy;gk`s0>|>@A+Bu~9gFeh3>;J1_IAkY^jc96 zz)6+g;2tMSXS+uO^7E1uI)Ct4_0p3i7ge1O%JpYq$R%Io zOeF8ryN?LH9*iyZyx#oaob;iwz6Gif$_kT72f;1Pny3&HcBqEP?Q_e$TcxY-V#q3Y zx$&l3TcO+acTVdlLsmpXUoWFqzT(nx<9%akD0&qdW%{@mc1C6DV{AzEV5xz3M_cZDEsueb*v2r;GcZ9|{~}Xt+coB`HhR+SKdS zSA!B4vwY*bO}QO>B_5JyrvILAgeSgI5XqdF*G>TTFOKl3pKQz4YqK9a;3d!0cS3T; zV3-Tr7>s5Pr1|`Dtb*kd&yG`dVZ5~75nLP22w7Y9+bf5nt1>UscCt5n*nx(Kz5G-W1^ zz=;7S0={Kjus?b+1I!)PI=TxS)kHNadxW7x8)h$&>(>;_H^6 zTdV%hGmgyim^_RzbM7AwsTvy&|Kaj%bX^E}*|Zh8)mXCFV)YUn%oiR#v_JK5W9}DN zXN9DQt+QmHtP3*VWA&$BP%RX|^i}|R5t^Tk6gUUm@SoNP`l3^BySIF?9PK-72Wzw8 z+rd0&cVZLq;b;erq$&dKZqDs--2-pwgb zxO&`+<845NMPOyA8DFjNZuX6WcEW{sfEyzMwEz^ zT!&2y0w4MqqSQ)UWxky``|i}Cf(xNjaQ6+=Qgsd*^FAJst8-qYn#f*ym4GgrH#gP_tZMm&?_@;#$txOaF3ILS0NwnLy0-tyn_lmrv@Rx!}`@ z4avJRD*;7)!p2IEggos35QmBJCBCH8_@7Ih|9XkR8Q6JvJ(iW>cK}WCl^{=W=9%c^U6^ z7({E+PV|jaRkGW*0Ok4V%Wuu?9|Yj@+h$iwiB-A|3VD+%6kL)JcCm=a)|6AB&AVDg zT+5FE(wBE@MZ_A1^$e>|+gEHK`2knZnsP+r=`zo%pHPGEv6q0xu#Y*luQ5(HB?S(p|H?~fCh-~#Bh%u1i+_!-Y-%N0NC6>N>sX9gI@?{W+A z!}W=I4g`l6ZpH4RcRuIdi|%O5t>Y7nZrB%~#>U(pmJ5py>ncyTv2^UoF3Um4Ve{4< zhR55*mgQ>4sd`%NhpCFfw<=`e;!F&yz-d4!L zTGjlyBT&R;Qa`GzEXCTio#Td$-r$%{W7xwpu#@1$^$?YIK;|FgU)KPJYdq^Ya9t>H zor~4Xya=VvUsLV1XX-2CdYwa1;hLx#6TriOitpU^0E{@9 z5Qa>N3eej|u3Mw?Bru78_79fu;zQ%s`nGp$*)C{)W(mF2$k>BtQM<5YxvV4@bEqk| zp3l#an;&`)@3o5}tbz!Agsoh{*75`h%Gl+#F#{q<5Vo7Q;UKsdei%oHhlySFa(INF z>&6YIY`4p=mhNm6OxtdDq88&}!=hf5w)hQjCkmgr`(f{M8|fwNwUaw-OX$HZfZ|}g zN;@pp_zf1|x3|D=B3?Ui;I{$bHzdHsE+tsuH&DQDmB4SJUOO1zw_$uZ+-t`RzeCu< z5HMZ@?LI?F+7naDm^UKYI9!EUE4Ca{gLsTQ;3&Igo9RQcbKd5)jL5OcD$#{$xH!fw zGz8-IZ31t5VDm7gt=`CFsU)UenGR#VV_I6g?KC{jUoNF%s}^@KN^vUJ;I2KcX&{T4 z#Ds?B)Lj~urzKp;Q75+flj|PXfdx;?BJeBzadPRUWYhdLjch8ExGo6OY?;i6%a)M@ETm zFLYH}#_oLOjG3aMZLMn+W@h8CR1=tYOb$3u;7@hzqd(O(m%$RN7TD(dZ?h=j_{fZo zTN!L@dDjn-KlRv_C8;CXlF*GGxzu6XWXa@a@92IailYBZRl~shTjbQLx;z+`H?c9~ zMNH6kflO_;iqYwWufNs`QLaB#TO@Ts9~o*!caoikGbkfGcR?w_+o-{2z}r=)a1r-AJ7y)^RLSbP{wOW^^g*k_lsk1>vv zRJCHrM^tAX+^zZ+y}t?9_cpNkJg4#m{8b5!m9kXta$AydzJ9a2G#zV!u z%SXG?PAW1lC7JrZq&n#JuEyMP`SKMHGx}SZ2mMNUZC50pyYvct9hcs$SzU!VWZT}D zG_1VD!FDC?7>;dKS1a@Y@EWUqlhPSY60u&C;4wG46yCyD>G!_xD^p$Nw*)=7ZB*_~ zogsqR()8E}7FwC`!OFKlG3}Kox|x~zS%nbtAqr~gxQk!ib-}2g>)RB`X-C9`^lg=A zEg%ZEU``TI%7T2D?imV56v?%;tXpBJJ@jfLG`5N6;gTa}kIk@@WKFAUAhYe|j1S)sCC_h$tB zL0-8|U_mnGKK?cN{3eHyJfRf!r%MtFct3%e;8R_~Gfj!goPkoK((M#ySPs>sbosC_ z1A;i6z`y3tDsL)xTyyf=ywsPW(#54OGY7^Glpa>|^*dmToDLJo2xJy8 zdA~0J-idxGI|!yEI;Lxkqb0SiOVp#*$RUBIG;Yx;hqtlD4|>>rDI$;ZDumhQ<*raW zEyjat0gYh1@(d>g2(8Y(&|2#a!`&p1yMz|q2}9yj&bSaW|Q!Ixn1}^X^AL^KWVyg?D z9D=yzEP0Ymq0{~5mq!x$yzWIK~J}9KdlZ|H8o*HknKB*%S|)#m>p2`xxh< zD4$R`j(OyTaT+-sG-ybKxVl`2H4)fsPo`a7(eaS9V8EG9FN%VWGWB(?zhW5I)*Y>UV`1ruF$I&KGwY zQNJ0pcCP~Qf%I`=iWbe$3+?W>1nNd#o(;jFC0$3+$&1b-WG4?XFWLzEdWMdTIQ0vI zOo|YBk>25!QVJ?!s{SEAH4riZBxc`59U^#PmR0P4Kbs84Ben#uzLf1zPPE6Sp^TPH zPovD6Ur*Al6b~A|ljgwN+fFfe%uOw2qThQYyZ_bt!`aF!l`DORZDu+wcY6BeKBc_~ z#2lY2d|M}X|65l7qc@pFB`{8LW}umd_R-4G>EYL1-{sbMW>{n()fMFBTZ%}rp}d}x zPrW>99rjBRBd0xdMLJ;Enn!dFb%}QnmsXy-@CccBQg7vCCNXT)d$W>$N}%;+7Vy#L zD56%ZS!hrS5v^|PIxIR9|7(uo4t81<$IA**F@~uv>@SuId`>>Eb;)>4u^Oe7#4NPX zubU`VYyB*I3||Wisb!emAC{4L*jmYHrrZLDy3VQzihcED>oTI>J|s}5&@9*BeUu|m z>NYvwtxK%ro-T1s{I(WT76QE?*x4EK=dn#}#RfkX;iJpm`*@6E$%=cg3-;)9r(hohx#M12*jDlI_sW z`e<)i#103ug`WDSQ+8%{~fekh-u>0DD7Wdi3IOE>Ym#e_Z-*|9dc0CPcBXA_5dgDc`epgD zgq|7GZ)T&^(>s2BQnXC5X6eMDlvXJ9YcuJK7N-*XD0f!%-cD^MV_+U$gRV8D%O<-w zEp_Hm5({mITEp5=jUPv8IM6lxJ*F?O0Nw5wdtIYyPt076()#XH0naBiPu0YQnAl06 zn&uK!jUxU#0k^#qtlV9A%()@<$Zo9n5S_TrqJ=G{L2PBdkg;)EL&o9RPNZ5l%{5mh zHbQ+2pS%BNCQR=!ATp57QXfTvuTHkw4~vM>n2|;O@{I)V?#oSG*QyZ&O{v~Xah}pn zZ`8z7ST%_#UG0HYAmMQjv8z8i)5-;Dw!(l6Wrh1)-|;onazeE-DS zBIlr8w4WCVN{F*A4DmU2uSw!pUlz=QQvfx6P$3+_?Ll^x_VlwOgjB!O=v_~1P~5#6 zd#4e1_v$~V(bQX3_JdV<^H|+tmQvr~Q@F#MI|E_Vtd9|QQm^+0SoggB>Q`yW?YZHm zZ_l9{Wzhp?@pw^uds8WiV>b(H0J)u%{#|)u^ZhT0+|4h&WQEwe+FS9w;~!_uGxezA z<$s*D8#GUSYp_e(!hRL$@{FYVTg+CI%6$n>8MyB%9EdHrVj6g}cdcioZp|`SVCbv? ztBUUX%VuiNO;24mitK7T;*(P_h%VfOdxfA|EUMiE$bk18BF08NLS#p2bs;s82TS9i4?4X4xK{{0dHC zJJ=H8#C7Lx+?!C5rN#`ge6+4WwHM9Isexqi7VEI^sU+tz7Ttx3Ep+D{asF~&`Qt~; zNuMpzD7Zr8sGiKn8&pa1Z@We&9k-cg{^?TN#G7eW#XdY}#5!Jgh*puA%P0C`1ofdB z>zWMHdR(R#3c7zVMS~RnIhZ#4t{TeeD=n#)E5FIL7>7^4g#*j)_QL_s{~QhkKOFho z)@%HZNiUO@tc=%AaEN8AkA{I1vOlab(XdRe%~cckoUfF{x+D;}?2;TYv-ka7`Rf$I zl#Y$<>mrO=FT*r%wiK_~V1BX0cipr5%!}!nK==1ZfP*L!c(&OgxgTPvU1ratGOBuxkavcT# z1L^tWGKY?}nFj5g?mhRqc$cv`KZ`}5$8UXex?%keho4Qs;4hh4C|1IV9d-GbAgNZz zYYn8tO5V3Vrjk^EoX>2yU^FT-e;9zPk^Y(ci-YBe_%P| zBo)*ZrqfL9xT^$~3R~92&u?)2P(4D{HtxD_uRIAy{$m#R{QH~#{@a3d`GSth#$*Yx zdmiz4xdaC82*z6imaS-hhO&mtE$vmxH#34~JkF^ja*LuG@!7pODz6yJ zar#-um>(7_9;elBnq2|jW)cWCKRRTmW^8fqdwjVU`QQx`jHGMe+lEQ@y(UMA{=N%O zhM{5(NoN`=C0KO-5V(yEwUDVwRQr{9JSaauv-R8zEtfqY<=44c3o#J zSEG{YC`qcaWn?vJTtMJ8Z?7Kto_1)>&+`c7j{E047Sz3YbGKw@V#&}2@z&D1c1FDW z!~Cz9vt+hsu6|hfw9HP`6>(bL_M+LD(CSaRA9mQ)!=YM`Tp2F-?M(keuT7}&KTW4W?U}pwY=`>k1 zQWZlQW(jE9CF$m0>ejC}`;1*)t*#`Ya*CYuxNPFw7t4Ds5ykd+znk@U-Om`fN|&df ze!DXba#M@>afkuz0G)vLy!5D=gqw`L4^T&TC#i|mD9fYs5~obXy01~Y`cNB$cgs?2 z=8&$|-9l_GhI-nq%;gfh?B}+|?L&cKs6*&af3Z}x@X|<+P)8;de5WH??yx~P z1_UM@kjaIMRnQDnmE-G2D zbttEK_wB z=pjZ32YD0)gL(28>$R&E*;U}DW=3q?&KtbV9}K3x0eIHkpT>7lcShuE%51fH^Og0t z1Gy(9X;eY z&lACY?8o=Nz5)XdKM&