diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index d0c07bb86fa3d..b023c7de37cd7 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -15,7 +15,7 @@
// Use 'postCreateCommand' to run commands after the container is created.
"postCreateCommand": {
- "Configure Build Tools": "sudo corepack enable npm; sudo npm install -g hereby; npm ci",
+ "Configure Build Tools": "sudo npm install -g hereby; npm ci",
"Install pprof": "go install github.com/google/pprof@latest",
"Install Graphviz": "sudo apt install graphviz"
},
diff --git a/.github/workflows/accept-baselines-fix-lints.yaml b/.github/workflows/accept-baselines-fix-lints.yaml
index 4f3ee8ef0767b..6a6c5caadd7e1 100644
--- a/.github/workflows/accept-baselines-fix-lints.yaml
+++ b/.github/workflows/accept-baselines-fix-lints.yaml
@@ -17,10 +17,10 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
token: ${{ secrets.TS_BOT_GITHUB_TOKEN }}
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 388db63970372..6b7552609cbaa 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -121,9 +121,9 @@ jobs:
name: Test Node ${{ matrix.config.node-version }} on ${{ matrix.config.os }}${{ (!matrix.config.bundle && ' with --no-bundle') || '' }}
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Use node version ${{ matrix.config.node-version }}
- uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: ${{ matrix.config.node-version }}
check-latest: true
@@ -154,8 +154,8 @@ jobs:
contents: read
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -179,8 +179,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -192,8 +192,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -205,13 +205,13 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
- - uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
+ - uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
with:
path: ~/.cache/dprint
key: ${{ runner.os }}-dprint-${{ hashFiles('package-lock.json', '.dprint.jsonc') }}
@@ -227,8 +227,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -243,8 +243,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -256,9 +256,9 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
@@ -297,16 +297,16 @@ jobs:
if: github.event_name == 'pull_request'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
path: pr
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
path: base
ref: ${{ github.base_ref }}
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
@@ -344,8 +344,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -360,8 +360,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
@@ -381,8 +381,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: npm ci
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index d715312240f51..c659ebdfdde92 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -42,11 +42,11 @@ jobs:
steps:
- name: Checkout repository
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
# Initializes the CodeQL tools for scanning.
- name: Initialize CodeQL
- uses: github/codeql-action/init@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+ uses: github/codeql-action/init@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
with:
config-file: ./.github/codeql/codeql-configuration.yml
# Override language selection by uncommenting this and choosing your languages
@@ -56,7 +56,7 @@ jobs:
# Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
# If this step fails, then you should remove it and run the build manually (see below).
- name: Autobuild
- uses: github/codeql-action/autobuild@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+ uses: github/codeql-action/autobuild@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
# âšī¸ Command-line programs to run using the OS shell.
# đ See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -70,4 +70,4 @@ jobs:
# make release
- name: Perform CodeQL Analysis
- uses: github/codeql-action/analyze@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+ uses: github/codeql-action/analyze@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
diff --git a/.github/workflows/copilot-setup-steps.yml b/.github/workflows/copilot-setup-steps.yml
index 5c8c2dd2485b2..3ba278f47a99a 100644
--- a/.github/workflows/copilot-setup-steps.yml
+++ b/.github/workflows/copilot-setup-steps.yml
@@ -15,8 +15,8 @@ jobs:
# You can define any steps you want, and they will run before the agent starts.
# If you do not check out your code, Copilot will do this for you.
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
- run: npm ci
# pull dprint caches before network access is blocked
- run: npx hereby check-format || true
diff --git a/.github/workflows/create-cherry-pick-pr.yml b/.github/workflows/create-cherry-pick-pr.yml
index 47c2be940481d..ecdd770e02776 100644
--- a/.github/workflows/create-cherry-pick-pr.yml
+++ b/.github/workflows/create-cherry-pick-pr.yml
@@ -47,7 +47,7 @@ jobs:
if: github.repository == 'microsoft/TypeScript'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
filter: blob:none # https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/
fetch-depth: 0 # Default is 1; need to set to 0 to get the benefits of blob:none.
diff --git a/.github/workflows/insiders.yaml b/.github/workflows/insiders.yaml
index 9c27709dae89b..7d33556e1b7bb 100644
--- a/.github/workflows/insiders.yaml
+++ b/.github/workflows/insiders.yaml
@@ -20,8 +20,8 @@ jobs:
if: github.repository == 'microsoft/TypeScript'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
@@ -42,8 +42,8 @@ jobs:
if: github.repository == 'microsoft/TypeScript'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
# Use NODE_AUTH_TOKEN environment variable to authenticate to this registry.
diff --git a/.github/workflows/lkg.yml b/.github/workflows/lkg.yml
index 3d1d1f50d27c8..5a3491d6c5e32 100644
--- a/.github/workflows/lkg.yml
+++ b/.github/workflows/lkg.yml
@@ -27,11 +27,11 @@ jobs:
exit 1
fi
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
ref: ${{ inputs.branch_name }}
token: ${{ secrets.TS_BOT_GITHUB_TOKEN }}
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
diff --git a/.github/workflows/new-release-branch.yaml b/.github/workflows/new-release-branch.yaml
index 7d96198753384..558162756c196 100644
--- a/.github/workflows/new-release-branch.yaml
+++ b/.github/workflows/new-release-branch.yaml
@@ -50,12 +50,12 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
filter: blob:none # https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/
fetch-depth: 0 # Default is 1; need to set to 0 to get the benefits of blob:none.
token: ${{ secrets.TS_BOT_GITHUB_TOKEN }}
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
diff --git a/.github/workflows/nightly.yaml b/.github/workflows/nightly.yaml
index faa9f3d615a73..92c74366730a1 100644
--- a/.github/workflows/nightly.yaml
+++ b/.github/workflows/nightly.yaml
@@ -21,8 +21,8 @@ jobs:
if: github.repository == 'microsoft/TypeScript'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
@@ -42,8 +42,8 @@ jobs:
if: github.repository == 'microsoft/TypeScript'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
# Use NODE_AUTH_TOKEN environment variable to authenticate to this registry.
diff --git a/.github/workflows/release-branch-artifact.yaml b/.github/workflows/release-branch-artifact.yaml
index 70ccb39435a83..27b1335bc3bb2 100644
--- a/.github/workflows/release-branch-artifact.yaml
+++ b/.github/workflows/release-branch-artifact.yaml
@@ -19,8 +19,8 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
index b5c0239a9301d..b23eba9b2a4b5 100644
--- a/.github/workflows/scorecard.yml
+++ b/.github/workflows/scorecard.yml
@@ -29,7 +29,7 @@ jobs:
steps:
- name: 'Checkout code'
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
persist-credentials: false
@@ -55,6 +55,6 @@ jobs:
# Upload the results to GitHub's code scanning dashboard.
- name: 'Upload to code-scanning'
- uses: github/codeql-action/upload-sarif@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+ uses: github/codeql-action/upload-sarif@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
with:
sarif_file: results.sarif
diff --git a/.github/workflows/set-version.yaml b/.github/workflows/set-version.yaml
index 77455eb3c7bd2..43729312642ff 100644
--- a/.github/workflows/set-version.yaml
+++ b/.github/workflows/set-version.yaml
@@ -49,11 +49,11 @@ jobs:
build:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
ref: ${{ inputs.branch_name }}
token: ${{ secrets.TS_BOT_GITHUB_TOKEN }}
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
diff --git a/.github/workflows/sync-branch.yaml b/.github/workflows/sync-branch.yaml
index 62c27289ebc94..c37eae0a14eb1 100644
--- a/.github/workflows/sync-branch.yaml
+++ b/.github/workflows/sync-branch.yaml
@@ -42,10 +42,10 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
ref: ${{ inputs.branch_name }}
filter: blob:none # https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/
diff --git a/.github/workflows/sync-wiki.yml b/.github/workflows/sync-wiki.yml
index 610f8170127e7..ebe024316b7ef 100644
--- a/.github/workflows/sync-wiki.yml
+++ b/.github/workflows/sync-wiki.yml
@@ -18,7 +18,7 @@ jobs:
- name: Get repo name
run: R=${GITHUB_REPOSITORY%?wiki}; echo "BASENAME=${R##*/}" >> $GITHUB_ENV
- name: Checkout ${{ env.BASENAME }}-wiki
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
repository: '${{ GITHUB.repository_owner }}/${{ env.BASENAME }}-wiki'
token: ${{ secrets.TS_BOT_GITHUB_TOKEN }}
diff --git a/.github/workflows/twoslash-repros.yaml b/.github/workflows/twoslash-repros.yaml
index 414be032b6d80..1b5b140026d9a 100644
--- a/.github/workflows/twoslash-repros.yaml
+++ b/.github/workflows/twoslash-repros.yaml
@@ -51,13 +51,13 @@ jobs:
runs-on: ubuntu-latest
steps:
- if: ${{ github.event.inputs.bisect }}
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
filter: blob:none # https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/
fetch-depth: 0 # Default is 1; need to set to 0 to get the benefits of blob:none.
- if: ${{ !github.event.inputs.bisect }}
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- uses: microsoft/TypeScript-Twoslash-Repro-Action@master
diff --git a/.github/workflows/update-package-lock.yaml b/.github/workflows/update-package-lock.yaml
index 7fa5d6ad6bf6f..4aaf3c451826d 100644
--- a/.github/workflows/update-package-lock.yaml
+++ b/.github/workflows/update-package-lock.yaml
@@ -22,10 +22,10 @@ jobs:
if: github.repository == 'microsoft/TypeScript'
steps:
- - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
token: ${{ secrets.TS_BOT_GITHUB_TOKEN }}
- - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
+ - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 'lts/*'
- run: |
diff --git a/Herebyfile.mjs b/Herebyfile.mjs
index aca96dc28c911..9195f631914e8 100644
--- a/Herebyfile.mjs
+++ b/Herebyfile.mjs
@@ -677,7 +677,7 @@ export const watchLocal = task({
dependencies: [localize, watchTsc, watchTsserver, watchServices, lssl, watchOtherOutputs, dts, watchSrc],
});
-const runtestsDeps = [tests, generateLibs].concat(cmdLineOptions.typecheck ? [dts] : []);
+const runtestsDeps = [tests, generateLibs, generateTypesMap].concat(cmdLineOptions.typecheck ? [dts] : []);
export const runTests = task({
name: "runtests",
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d0d53aea61c00..5d446f6799418 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3794,6 +3794,21 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// are ESM, there cannot be a synthetic default.
return false;
}
+ // For other files (not node16/nodenext with impliedNodeFormat), check if we can determine
+ // the module format from project references
+ if (!targetMode && file.isDeclarationFile) {
+ // Try to get the project reference - try both source file mapping and output file mapping
+ // since declaration files can be mapped either way depending on how they're resolved
+ const redirect = host.getRedirectFromSourceFile(file.path) || host.getRedirectFromOutput(file.path);
+ if (redirect) {
+ // This is a declaration file from a project reference, so we can determine
+ // its module format from the referenced project's options
+ const targetModuleKind = host.getEmitModuleFormatOfFile(file);
+ if (usageMode === ModuleKind.ESNext && ModuleKind.ES2015 <= targetModuleKind && targetModuleKind <= ModuleKind.ESNext) {
+ return false;
+ }
+ }
+ }
}
if (!allowSyntheticDefaultImports) {
return false;
@@ -15332,6 +15347,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
undefined;
}
if (t.flags & TypeFlags.Index) {
+ if (isGenericMappedType((t as IndexType).type)) {
+ const mappedType = (t as IndexType).type as MappedType;
+ if (getNameTypeFromMappedType(mappedType) && !isMappedTypeWithKeyofConstraintDeclaration(mappedType)) {
+ return getBaseConstraint(getIndexTypeForMappedType(mappedType, IndexFlags.None));
+ }
+ }
return stringNumberSymbolType;
}
if (t.flags & TypeFlags.TemplateLiteral) {
@@ -18824,7 +18845,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// a circular definition. For this reason, we only eagerly manifest the keys if the constraint is non-generic.
if (isGenericIndexType(constraintType)) {
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
- // We have a generic index and a homomorphic mapping (but a distributive key remapping) - we need to defer
+ // We have a generic index and a homomorphic mapping and a key remapping - we need to defer
// the whole `keyof whatever` for later since it's not safe to resolve the shape of modifier type.
return getIndexTypeForGenericType(type, indexFlags);
}
@@ -18854,25 +18875,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
}
- // Ordinarily we reduce a keyof M, where M is a mapped type { [P in K as N
]: X }, to simply N. This however presumes
- // that N distributes over union types, i.e. that N is equivalent to N | N | N. Specifically, we only
- // want to perform the reduction when the name type of a mapped type is distributive with respect to the type variable
- // introduced by the 'in' clause of the mapped type. Note that non-generic types are considered to be distributive because
- // they're the same type regardless of what's being distributed over.
- function hasDistributiveNameType(mappedType: MappedType) {
- const typeVariable = getTypeParameterFromMappedType(mappedType);
- return isDistributive(getNameTypeFromMappedType(mappedType) || typeVariable);
- function isDistributive(type: Type): boolean {
- return type.flags & (TypeFlags.AnyOrUnknown | TypeFlags.Primitive | TypeFlags.Never | TypeFlags.TypeParameter | TypeFlags.Object | TypeFlags.NonPrimitive) ? true :
- type.flags & TypeFlags.Conditional ? (type as ConditionalType).root.isDistributive && (type as ConditionalType).checkType === typeVariable :
- type.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral) ? every((type as UnionOrIntersectionType | TemplateLiteralType).types, isDistributive) :
- type.flags & TypeFlags.IndexedAccess ? isDistributive((type as IndexedAccessType).objectType) && isDistributive((type as IndexedAccessType).indexType) :
- type.flags & TypeFlags.Substitution ? isDistributive((type as SubstitutionType).baseType) && isDistributive((type as SubstitutionType).constraint) :
- type.flags & TypeFlags.StringMapping ? isDistributive((type as StringMappingType).type) :
- false;
- }
- }
-
function getLiteralTypeFromPropertyName(name: PropertyName | JsxAttributeName) {
if (isPrivateIdentifier(name)) {
return neverType;
@@ -18924,7 +18926,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
function shouldDeferIndexType(type: Type, indexFlags = IndexFlags.None) {
return !!(type.flags & TypeFlags.InstantiableNonPrimitive ||
isGenericTupleType(type) ||
- isGenericMappedType(type) && (!hasDistributiveNameType(type) || getMappedTypeNameTypeKind(type) === MappedTypeNameTypeKind.Remapping) ||
+ isGenericMappedType(type) && getNameTypeFromMappedType(type) ||
type.flags & TypeFlags.Union && !(indexFlags & IndexFlags.NoReducibleCheck) && isGenericReducibleType(type) ||
type.flags & TypeFlags.Intersection && maybeTypeOfKind(type, TypeFlags.Instantiable) && some((type as IntersectionType).types, isEmptyAnonymousObjectType));
}
@@ -19445,6 +19447,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
function getSimplifiedType(type: Type, writing: boolean): Type {
return type.flags & TypeFlags.IndexedAccess ? getSimplifiedIndexedAccessType(type as IndexedAccessType, writing) :
type.flags & TypeFlags.Conditional ? getSimplifiedConditionalType(type as ConditionalType, writing) :
+ type.flags & TypeFlags.Index ? getSimplifiedIndexType(type as IndexType) :
type;
}
@@ -19544,6 +19547,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
return type;
}
+ function getSimplifiedIndexType(type: IndexType) {
+ if (isGenericMappedType(type.type) && getNameTypeFromMappedType(type.type) && !isMappedTypeWithKeyofConstraintDeclaration(type.type)) {
+ return getIndexTypeForMappedType(type.type, IndexFlags.None);
+ }
+ return type;
+ }
+
/**
* Invokes union simplification logic to determine if an intersection is considered empty as a union constituent
*/
@@ -24881,7 +24891,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
function discriminateTypeByDiscriminableItems(target: UnionType, discriminators: (readonly [() => Type, __String])[], related: (source: Type, target: Type) => boolean | Ternary) {
const types = target.types;
- const include: Ternary[] = types.map(t => t.flags & TypeFlags.Primitive ? Ternary.False : Ternary.True);
+ const include: Ternary[] = types.map(t => t.flags & TypeFlags.Primitive || getReducedType(t).flags & TypeFlags.Never ? Ternary.False : Ternary.True);
for (const [getDiscriminatingType, propertyName] of discriminators) {
// If the remaining target types include at least one with a matching discriminant, eliminate those that
// have non-matching discriminants. This ensures that we ignore erroneous discriminators and gradually
@@ -31113,7 +31123,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// We only look for uninitialized variables in strict null checking mode, and only when we can analyze
// the entire control flow graph from the variable's declaration (i.e. when the flow container and
// declaration container are the same).
- const isNeverInitialized = immediateDeclaration && isVariableDeclaration(immediateDeclaration) && !immediateDeclaration.initializer && !immediateDeclaration.exclamationToken && isMutableLocalVariableDeclaration(immediateDeclaration) && !isSymbolAssignedDefinitely(symbol);
+ const isNeverInitialized = immediateDeclaration && isVariableDeclaration(immediateDeclaration) && !isForInOrOfStatement(immediateDeclaration.parent.parent) && !immediateDeclaration.initializer && !immediateDeclaration.exclamationToken && isMutableLocalVariableDeclaration(immediateDeclaration) && !isSymbolAssignedDefinitely(symbol);
const assumeInitialized = isParameter || isAlias ||
(isOuterVariable && !isNeverInitialized) ||
isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) ||
@@ -40548,12 +40558,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
}
checkNullishCoalesceOperandLeft(node);
- checkNullishCoalesceOperandRight(node);
}
function checkNullishCoalesceOperandLeft(node: BinaryExpression) {
const leftTarget = skipOuterExpressions(node.left, OuterExpressionKinds.All);
-
const nullishSemantics = getSyntacticNullishnessSemantics(leftTarget);
if (nullishSemantics !== PredicateSemantics.Sometimes) {
if (nullishSemantics === PredicateSemantics.Always) {
@@ -40565,25 +40573,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
}
- function checkNullishCoalesceOperandRight(node: BinaryExpression) {
- const rightTarget = skipOuterExpressions(node.right, OuterExpressionKinds.All);
- const nullishSemantics = getSyntacticNullishnessSemantics(rightTarget);
- if (isNotWithinNullishCoalesceExpression(node)) {
- return;
- }
-
- if (nullishSemantics === PredicateSemantics.Always) {
- error(rightTarget, Diagnostics.This_expression_is_always_nullish);
- }
- else if (nullishSemantics === PredicateSemantics.Never) {
- error(rightTarget, Diagnostics.This_expression_is_never_nullish);
- }
- }
-
- function isNotWithinNullishCoalesceExpression(node: BinaryExpression) {
- return !isBinaryExpression(node.parent) || node.parent.operatorToken.kind !== SyntaxKind.QuestionQuestionToken;
- }
-
function getSyntacticNullishnessSemantics(node: Node): PredicateSemantics {
node = skipOuterExpressions(node);
switch (node.kind) {
@@ -40601,15 +40590,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// List of operators that can produce null/undefined:
// = ??= ?? || ||= && &&=
switch ((node as BinaryExpression).operatorToken.kind) {
- case SyntaxKind.EqualsToken:
- case SyntaxKind.QuestionQuestionToken:
- case SyntaxKind.QuestionQuestionEqualsToken:
case SyntaxKind.BarBarToken:
case SyntaxKind.BarBarEqualsToken:
case SyntaxKind.AmpersandAmpersandToken:
case SyntaxKind.AmpersandAmpersandEqualsToken:
return PredicateSemantics.Sometimes;
+ // For these operator kinds, the right operand is effectively controlling
case SyntaxKind.CommaToken:
+ case SyntaxKind.EqualsToken:
+ case SyntaxKind.QuestionQuestionToken:
+ case SyntaxKind.QuestionQuestionEqualsToken:
return getSyntacticNullishnessSemantics((node as BinaryExpression).right);
}
return PredicateSemantics.Never;
@@ -42859,12 +42849,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// Check if the index type is assignable to 'keyof T' for the object type.
const objectType = (type as IndexedAccessType).objectType;
const indexType = (type as IndexedAccessType).indexType;
- // skip index type deferral on remapping mapped types
- const objectIndexType = isGenericMappedType(objectType) && getMappedTypeNameTypeKind(objectType) === MappedTypeNameTypeKind.Remapping
- ? getIndexTypeForMappedType(objectType, IndexFlags.None)
- : getIndexType(objectType, IndexFlags.None);
const hasNumberIndexInfo = !!getIndexInfoOfType(objectType, numberType);
- if (everyType(indexType, t => isTypeAssignableTo(t, objectIndexType) || hasNumberIndexInfo && isApplicableIndexType(t, numberType))) {
+ if (everyType(indexType, t => isTypeAssignableTo(t, getIndexType(objectType, IndexFlags.None)) || hasNumberIndexInfo && isApplicableIndexType(t, numberType))) {
if (
accessNode.kind === SyntaxKind.ElementAccessExpression && isAssignmentTarget(accessNode) &&
getObjectFlags(objectType) & ObjectFlags.Mapped && getMappedTypeModifiers(objectType as MappedType) & MappedTypeModifiers.IncludeReadonly
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 03f5f19a69877..1a69dba02a6c1 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -4480,6 +4480,10 @@
"category": "Error",
"code": 5010
},
+ "The common source directory of '{0}' is '{1}'. The 'rootDir' setting must be explicitly set to this or another path to adjust your output's file layout.": {
+ "category": "Error",
+ "code": 5011
+ },
"Cannot read file '{0}': {1}.": {
"category": "Error",
"code": 5012
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 000861e55dd44..9ba1afcae27ea 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -646,7 +646,7 @@ export function getCommonSourceDirectory(
commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);
checkSourceFilesBelongToPath?.(options.rootDir);
}
- else if (options.composite && options.configFilePath) {
+ else if (options.configFilePath) {
// Project compilations never infer their root from the input source paths
commonSourceDirectory = getDirectoryPath(normalizeSlashes(options.configFilePath));
checkSourceFilesBelongToPath?.(commonSourceDirectory);
@@ -664,6 +664,23 @@ export function getCommonSourceDirectory(
return commonSourceDirectory;
}
+/** @internal */
+export function getComputedCommonSourceDirectory(
+ emittedFiles: readonly string[],
+ currentDirectory: string,
+ getCanonicalFileName: GetCanonicalFileName,
+): string {
+ let commonSourceDirectory = computeCommonSourceDirectoryOfFilenames(emittedFiles, currentDirectory, getCanonicalFileName);
+
+ if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) {
+ // Make sure directory path ends with directory separator so this string can directly
+ // used to replace with "" to get the relative path of the source file and the relative path doesn't
+ // start with / making it rooted path
+ commonSourceDirectory += directorySeparator;
+ }
+ return commonSourceDirectory;
+}
+
/** @internal */
export function getCommonSourceDirectoryOfConfig({ options, fileNames }: ParsedCommandLine, ignoreCase: boolean): string {
return getCommonSourceDirectory(
diff --git a/src/compiler/executeCommandLine.ts b/src/compiler/executeCommandLine.ts
index 6b6fb23683ca2..0ed4cfd96a45f 100644
--- a/src/compiler/executeCommandLine.ts
+++ b/src/compiler/executeCommandLine.ts
@@ -157,7 +157,13 @@ function updateReportDiagnostic(
}
function defaultIsPretty(sys: System) {
- return !!sys.writeOutputIsTTY && sys.writeOutputIsTTY() && !sys.getEnvironmentVariable("NO_COLOR");
+ if (sys.getEnvironmentVariable("NO_COLOR")) {
+ return false;
+ }
+ if (sys.getEnvironmentVariable("FORCE_COLOR")) {
+ return true;
+ }
+ return !!sys.writeOutputIsTTY && sys.writeOutputIsTTY();
}
function shouldBePretty(sys: System, options: CompilerOptions | BuildOptions) {
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
index 2bf692f6298a6..d665072ae51b5 100644
--- a/src/compiler/moduleNameResolver.ts
+++ b/src/compiler/moduleNameResolver.ts
@@ -2889,7 +2889,7 @@ function getLoadModuleFromTargetExportOrImport(extensions: Extensions, state: Mo
const commonSourceDirGuesses: string[] = [];
// A `rootDir` compiler option strongly indicates the root location
// A `composite` project is using project references and has it's common src dir set to `.`, so it shouldn't need to check any other locations
- if (state.compilerOptions.rootDir || (state.compilerOptions.composite && state.compilerOptions.configFilePath)) {
+ if (state.compilerOptions.rootDir || state.compilerOptions.configFilePath) {
const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [], state.host.getCurrentDirectory?.() || "", getCanonicalFileName));
commonSourceDirGuesses.push(commonDir);
}
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 323b887b20c2b..e56c0353cd3bc 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -109,6 +109,7 @@ import {
GetCanonicalFileName,
getCommonSourceDirectory as ts_getCommonSourceDirectory,
getCommonSourceDirectoryOfConfig,
+ getComputedCommonSourceDirectory,
getDeclarationDiagnostics as ts_getDeclarationDiagnostics,
getDefaultLibFileName,
getDirectoryPath,
@@ -132,6 +133,7 @@ import {
getPackageScopeForPath,
getPathFromPathComponents,
getPositionOfLineAndCharacter,
+ getRelativePathFromFile,
getResolvedModuleFromResolution,
getResolvedTypeReferenceDirectiveFromResolution,
getResolveJsonModule,
@@ -4254,6 +4256,35 @@ export function createProgram(_rootNamesOrOptions: readonly string[] | CreatePro
}
}
+ if (
+ !options.noEmit &&
+ !options.composite &&
+ !options.rootDir &&
+ options.configFilePath &&
+ (options.outDir || // there is --outDir specified
+ (getEmitDeclarations(options) && options.declarationDir) || // there is --declarationDir specified
+ options.outFile)
+ ) {
+ // Check if rootDir inferred changed and issue diagnostic
+ const dir = getCommonSourceDirectory();
+ const emittedFiles = mapDefined(files, file => !file.isDeclarationFile && sourceFileMayBeEmitted(file, program) ? file.fileName : undefined);
+ const dir59 = getComputedCommonSourceDirectory(emittedFiles, currentDirectory, getCanonicalFileName);
+ if (dir59 !== "" && getCanonicalFileName(dir) !== getCanonicalFileName(dir59)) {
+ // change in layout
+ createDiagnosticForOption(
+ /*onKey*/ true,
+ options.outFile ? "outFile" : options.outDir ? "outDir" : "declarationDir",
+ !options.outFile && options.outDir ? "declarationDir" : undefined,
+ chainDiagnosticMessages(
+ chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashts6_for_migration_information),
+ Diagnostics.The_common_source_directory_of_0_is_1_The_rootDir_setting_must_be_explicitly_set_to_this_or_another_path_to_adjust_your_output_s_file_layout,
+ getBaseFileName(options.configFilePath),
+ getRelativePathFromFile(options.configFilePath, dir59, getCanonicalFileName),
+ ),
+ );
+ }
+ }
+
if (options.checkJs && !getAllowJSCompilerOption(options)) {
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs");
}
@@ -4484,7 +4515,7 @@ export function createProgram(_rootNamesOrOptions: readonly string[] | CreatePro
createDeprecatedDiagnostic("charset");
}
if (options.out) {
- createDeprecatedDiagnostic("out", /*value*/ undefined, "outFile");
+ createDeprecatedDiagnostic("out");
}
if (options.importsNotUsedAsValues) {
createDeprecatedDiagnostic("importsNotUsedAsValues", /*value*/ undefined, "verbatimModuleSyntax");
@@ -4510,6 +4541,9 @@ export function createProgram(_rootNamesOrOptions: readonly string[] | CreatePro
if (options.allowSyntheticDefaultImports === false) {
createDeprecatedDiagnostic("allowSyntheticDefaultImports", "false", /*useInstead*/ undefined, /*related*/ undefined);
}
+ if (options.outFile) {
+ createDeprecatedDiagnostic("outFile");
+ }
if (options.module === ModuleKind.None || options.module === ModuleKind.AMD || options.module === ModuleKind.UMD || options.module === ModuleKind.System) {
createDeprecatedDiagnostic("module", ModuleKind[options.module], /*useInstead*/ undefined, /*related*/ undefined);
}
diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts
index 7bced48353b82..6f1fc390723ad 100644
--- a/src/compiler/resolutionCache.ts
+++ b/src/compiler/resolutionCache.ts
@@ -199,6 +199,9 @@ export interface ResolutionCacheHost extends MinimalResolutionCacheHost {
fileIsOpen(filePath: Path): boolean;
onDiscoveredSymlink?(): void;
+ skipWatchingFailedLookups?(path: Path): boolean | undefined;
+ skipWatchingTypeRoots?(): boolean | undefined;
+
// For incremental testing
beforeResolveSingleModuleNameWithoutWatching?(
moduleResolutionCache: ModuleResolutionCache,
@@ -895,7 +898,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
resolutionHost.onDiscoveredSymlink();
}
resolutionsInFile.set(name, mode, resolution);
- if (resolution !== existingResolution) {
+ if (resolution !== existingResolution && !resolutionHost.skipWatchingFailedLookups?.(path)) {
watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
if (existingResolution) {
stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
@@ -947,7 +950,9 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
// Stop watching and remove the unused name
resolutionsInFile.forEach((resolution, name, mode) => {
if (!seenNamesInFile.has(name, mode)) {
- stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
+ if (!resolutionHost.skipWatchingFailedLookups?.(path)) {
+ stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
+ }
resolutionsInFile.delete(name, mode);
}
});
@@ -1434,13 +1439,15 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
// Deleted file, stop watching failed lookups for all the resolutions in the file
const resolutions = cache.get(filePath);
if (resolutions) {
- resolutions.forEach(resolution =>
- stopWatchFailedLookupLocationOfResolution(
- resolution,
- filePath,
- getResolutionWithResolvedFileName,
- )
- );
+ if (!resolutionHost.skipWatchingFailedLookups?.(filePath)) {
+ resolutions.forEach(resolution =>
+ stopWatchFailedLookupLocationOfResolution(
+ resolution,
+ filePath,
+ getResolutionWithResolvedFileName,
+ )
+ );
+ }
cache.delete(filePath);
}
}
@@ -1667,6 +1674,12 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
return;
}
+ // if this is inferred project with non watchable root or current directory that is lib location, skip watching type roots
+ if (!isRootWatchable || resolutionHost.skipWatchingTypeRoots?.()) {
+ closeTypeRootsWatch();
+ return;
+ }
+
// we need to assume the directories exist to ensure that we can get all the type root directories that get included
// But filter directories that are at root level to say directory doesnt exist, so that we arent watching them
const typeRoots = getEffectiveTypeRoots(options, { getCurrentDirectory });
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index cc3da23d2067b..2219f2b1211a1 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -1055,6 +1055,10 @@ export function transformTypeScript(context: TransformationContext): Transformer
if (parametersWithPropertyAssignments) {
for (const parameter of parametersWithPropertyAssignments) {
+ // Ignore parameter properties with destructured names; we will have errored on them earlier.
+ if (!isIdentifier(parameter.name)) {
+ continue;
+ }
const parameterProperty = factory.createPropertyDeclaration(
/*modifiers*/ undefined,
parameter.name,
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index ef01015982139..4e9f872720d79 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -6394,7 +6394,7 @@ export const enum TypeFlags {
/** @internal */
ObjectFlagsType = Any | Nullable | Never | Object | Union | Intersection,
/** @internal */
- Simplifiable = IndexedAccess | Conditional,
+ Simplifiable = IndexedAccess | Conditional | Index,
/** @internal */
Singleton = Any | Unknown | String | Number | Boolean | BigInt | ESSymbol | Void | Undefined | Null | Never | NonPrimitive,
// 'Narrowable' types are types where narrowing actually narrows.
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index ba6b6d253a31c..9a78e2de7a949 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -6632,7 +6632,7 @@ export function sourceFileMayBeEmitted(sourceFile: SourceFile, host: SourceFileM
// Json file is not emitted if outDir is not specified
if (!options.outDir) return false;
// Otherwise if rootDir or composite config file, we know common sourceDir and can check if file would be emitted in same location
- if (options.rootDir || (options.composite && options.configFilePath)) {
+ if (options.rootDir || options.configFilePath) {
const commonDir = getNormalizedAbsolutePath(getCommonSourceDirectory(options, () => [], host.getCurrentDirectory(), host.getCanonicalFileName), host.getCurrentDirectory());
const outputPath = getSourceFilePathInNewDirWorker(sourceFile.fileName, options.outDir, host.getCurrentDirectory(), commonDir, host.getCanonicalFileName);
if (comparePaths(sourceFile.fileName, outputPath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === Comparison.EqualTo) return false;
diff --git a/src/harness/evaluatorImpl.ts b/src/harness/evaluatorImpl.ts
index 2e2124b64e068..7b434403eb15c 100644
--- a/src/harness/evaluatorImpl.ts
+++ b/src/harness/evaluatorImpl.ts
@@ -39,6 +39,7 @@ export function evaluateTypeScript(source: string | { files: vfs.FileSet; rootFi
const compilerOptions: ts.CompilerOptions = {
target: ts.ScriptTarget.ES5,
module: ts.ModuleKind.CommonJS,
+ strict: false,
lib: ["lib.esnext.d.ts", "lib.dom.d.ts"],
...options,
};
diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts
index 5b1c66546da88..dc6341ef018f7 100644
--- a/src/harness/fourslashImpl.ts
+++ b/src/harness/fourslashImpl.ts
@@ -9,10 +9,7 @@ import * as vpath from "./_namespaces/vpath.js";
import { LoggerWithInMemoryLogs } from "./tsserverLogger.js";
import ArrayOrSingle = FourSlashInterface.ArrayOrSingle;
-import {
- harnessSessionLibLocation,
- harnessTypingInstallerCacheLocation,
-} from "./harnessLanguageService.js";
+import { harnessTypingInstallerCacheLocation } from "./harnessLanguageService.js";
import { ensureWatchablePath } from "./watchUtils.js";
export const enum FourSlashTestType {
@@ -105,7 +102,7 @@ const enum MetadataOptionNames {
const fileMetadataNames = [MetadataOptionNames.fileName, MetadataOptionNames.emitThisFile, MetadataOptionNames.resolveReference, MetadataOptionNames.symlink];
function convertGlobalOptionsToCompilerOptions(globalOptions: Harness.TestCaseParser.CompilerSettings): ts.CompilerOptions {
- const settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5, newLine: ts.NewLineKind.CarriageReturnLineFeed };
+ const settings: ts.CompilerOptions = { ...ts.getDefaultCompilerOptions(), jsx: undefined, newLine: ts.NewLineKind.CarriageReturnLineFeed };
Harness.Compiler.setCompilerOptionsFromHarnessSetting(globalOptions, settings);
return settings;
}
@@ -367,11 +364,6 @@ export class TestState {
}
}
- const libName = (name: string) =>
- this.testType !== FourSlashTestType.Server ?
- name :
- `${harnessSessionLibLocation}/${name}`;
-
let configParseResult: ts.ParsedCommandLine | undefined;
if (configFileName) {
const baseDir = ts.normalizePath(ts.getDirectoryPath(configFileName));
@@ -422,24 +414,6 @@ export class TestState {
const importedFilePath = this.basePath + "/" + importedFile.fileName;
this.addMatchedInputFile(importedFilePath, exts);
});
-
- this.languageServiceAdapterHost.addScript(
- libName(Harness.Compiler.defaultLibFileName),
- Harness.Compiler.getDefaultLibrarySourceFile()!.text,
- /*isRootFile*/ false,
- );
-
- compilationOptions.lib?.forEach(fileName => {
- const libFile = Harness.Compiler.getDefaultLibrarySourceFile(fileName);
- ts.Debug.assertIsDefined(libFile, `Could not find lib file '${fileName}'`);
- if (libFile) {
- this.languageServiceAdapterHost.addScript(
- libName(fileName),
- libFile.text,
- /*isRootFile*/ false,
- );
- }
- });
}
else {
// resolveReference file-option is not specified then do not resolve any files and include all inputFiles
@@ -452,24 +426,6 @@ export class TestState {
this.languageServiceAdapterHost.addScript(fileName, file, isRootFile);
}
});
-
- if (!compilationOptions.noLib) {
- const seen = new Set();
- const addSourceFile = (fileName: string) => {
- if (seen.has(fileName)) return;
- seen.add(fileName);
- const libFile = Harness.Compiler.getDefaultLibrarySourceFile(fileName);
- ts.Debug.assertIsDefined(libFile, `Could not find lib file '${fileName}'`);
- this.languageServiceAdapterHost.addScript(libName(fileName), libFile.text, /*isRootFile*/ false);
- if (!ts.some(libFile.libReferenceDirectives)) return;
- for (const directive of libFile.libReferenceDirectives) {
- addSourceFile(`lib.${directive.fileName}.d.ts`);
- }
- };
-
- addSourceFile(Harness.Compiler.defaultLibFileName);
- compilationOptions.lib?.forEach(addSourceFile);
- }
}
for (const file of testData.files) {
@@ -557,7 +513,13 @@ export class TestState {
}
private tryGetFileContent(fileName: string): string | undefined {
const script = this.languageServiceAdapterHost.getScriptInfo(fileName);
- return script && script.content;
+ if (script) return script.content;
+ try {
+ return this.languageServiceAdapterHost.vfs.readFileSync(fileName, "utf8");
+ }
+ catch {
+ return undefined;
+ }
}
// Entry points from fourslash.ts
@@ -4870,18 +4832,6 @@ function parseTestData(basePath: string, contents: string, fileName: string): Fo
}
}
- // @Filename is the only directive that can be used in a test that contains tsconfig.json file.
- const config = ts.find(files, isConfig);
- if (config) {
- let directive = getNonFileNameOptionInFileList(files);
- if (!directive) {
- directive = getNonFileNameOptionInObject(globalOptions);
- }
- if (directive) {
- throw Error(`It is not allowed to use ${config.fileName} along with directive '${directive}'`);
- }
- }
-
return {
markerPositions,
markers,
@@ -4896,24 +4846,6 @@ function isConfig(file: FourSlashFile): boolean {
return Harness.getConfigNameFromFileName(file.fileName) !== undefined;
}
-function getNonFileNameOptionInFileList(files: FourSlashFile[]): string | undefined {
- return ts.forEach(files, f => getNonFileNameOptionInObject(f.fileOptions));
-}
-
-function getNonFileNameOptionInObject(optionObject: { [s: string]: string; }): string | undefined {
- for (const option in optionObject) {
- switch (option) {
- case MetadataOptionNames.fileName:
- case MetadataOptionNames.baselineFile:
- case MetadataOptionNames.emitThisFile:
- break;
- default:
- return option;
- }
- }
- return undefined;
-}
-
const enum State {
none,
inSlashStarMarker,
diff --git a/src/harness/harnessIO.ts b/src/harness/harnessIO.ts
index 62eb692058e67..a06bde1c95182 100644
--- a/src/harness/harnessIO.ts
+++ b/src/harness/harnessIO.ts
@@ -229,48 +229,6 @@ export namespace Compiler {
return result;
}
- export const defaultLibFileName = "lib.d.ts";
- export const es2015DefaultLibFileName = "lib.es2015.d.ts";
-
- // Cache of lib files from "built/local"
- export let libFileNameSourceFileMap: Map | undefined;
-
- export function getDefaultLibrarySourceFile(fileName: string = defaultLibFileName): ts.SourceFile | undefined {
- if (!isDefaultLibraryFile(fileName)) {
- return undefined;
- }
-
- if (!libFileNameSourceFileMap) {
- const file = createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts")!, /*languageVersion*/ ts.ScriptTarget.Latest);
- libFileNameSourceFileMap = new Map(Object.entries({
- [defaultLibFileName]: { file, stringified: JSON.stringify(file.text) },
- }));
- }
-
- let sourceFile = libFileNameSourceFileMap.get(fileName);
- if (!sourceFile) {
- const file = createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName)!, ts.ScriptTarget.Latest);
- sourceFile = { file, stringified: JSON.stringify(file.text) };
- libFileNameSourceFileMap.set(fileName, sourceFile);
- }
- return sourceFile.file;
- }
-
- export function getDefaultLibFileName(options: ts.CompilerOptions): string {
- switch (ts.getEmitScriptTarget(options)) {
- case ts.ScriptTarget.ESNext:
- case ts.ScriptTarget.ES2017:
- return "lib.es2017.d.ts";
- case ts.ScriptTarget.ES2016:
- return "lib.es2016.d.ts";
- case ts.ScriptTarget.ES2015:
- return es2015DefaultLibFileName;
-
- default:
- return defaultLibFileName;
- }
- }
-
// Cache these between executions so we don't have to re-parse them for every test
export const fourslashFileName = "fourslash.ts";
export let fourslashSourceFile: ts.SourceFile;
@@ -281,9 +239,7 @@ export namespace Compiler {
interface HarnessOptions {
useCaseSensitiveFileNames?: boolean;
- includeBuiltFile?: string;
baselineFile?: string;
- libFiles?: string;
noTypesAndSymbols?: boolean;
captureSuggestions?: boolean;
}
@@ -293,9 +249,7 @@ export namespace Compiler {
{ name: "allowNonTsExtensions", type: "boolean", defaultValueDescription: false },
{ name: "useCaseSensitiveFileNames", type: "boolean", defaultValueDescription: false },
{ name: "baselineFile", type: "string" },
- { name: "includeBuiltFile", type: "string" },
{ name: "fileName", type: "string" },
- { name: "libFiles", type: "string" },
{ name: "noErrorTruncation", type: "boolean", defaultValueDescription: false },
{ name: "suppressOutputPathCheck", type: "boolean", defaultValueDescription: false },
{ name: "noImplicitReferences", type: "boolean", defaultValueDescription: false },
@@ -412,23 +366,6 @@ export namespace Compiler {
.map(file => options.configFile ? ts.getNormalizedAbsolutePath(file.unitName, currentDirectory) : file.unitName)
.filter(fileName => !ts.fileExtensionIs(fileName, ts.Extension.Json));
- // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
- // Treat them as library files, so include them in build, but not in baselines.
- if (options.includeBuiltFile) {
- programFileNames.push(vpath.combine(vfs.builtFolder, options.includeBuiltFile));
- }
-
- // Files from tests\lib that are requested by "@libFiles"
- if (options.libFiles) {
- for (const fileName of options.libFiles.split(",")) {
- if (fileName === "lib.d.ts" && !options.noLib) {
- // Hack from Corsa.
- continue;
- }
- programFileNames.push(vpath.combine(vfs.testLibFolder, fileName));
- }
- }
-
const docs = inputFiles.concat(otherFiles).map(documents.TextDocument.fromTestFile);
const fs = vfs.createFromFileSystem(IO, !useCaseSensitiveFileNames, { documents: docs, cwd: currentDirectory });
if (symlinks) {
@@ -1062,7 +999,7 @@ export namespace Compiler {
function fileOutput(file: documents.TextDocument, harnessSettings: TestCaseParser.CompilerSettings): string {
const fileName = harnessSettings.fullEmitPaths ? Utils.removeTestPathPrefixes(file.file) : ts.getBaseFileName(file.file);
- return "//// [" + fileName + "]\r\n" + Utils.removeTestPathPrefixes(file.text);
+ return "//// [" + fileName + "]\r\n" + file.text;
}
export function collateOutputs(outputFiles: readonly documents.TextDocument[]): string {
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index 7aff47310a4b6..1703d466619aa 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -1,7 +1,7 @@
import * as collections from "./_namespaces/collections.js";
import * as fakes from "./_namespaces/fakes.js";
import {
- Compiler,
+ IO,
mockHash,
virtualFileSystemRoot,
} from "./_namespaces/Harness.js";
@@ -128,13 +128,122 @@ export interface LanguageServiceAdapter {
getLogger(): LoggerWithInMemoryLogs | undefined;
}
+/** Create VFS with libs only at fourslashLibFolder */
+function createLanguageServiceVfs(): vfs.FileSystem {
+ return vfs.createFourslashVfs(IO, /*ignoreCase*/ true, { cwd: virtualFileSystemRoot });
+}
+
+// Cache lib file SourceFiles directly to avoid reparsing across tests.
+// Lib .d.ts files parse identically regardless of compiler settings, so we cache
+// just one copy per path. This persists for the entire test run.
+const libSourceFileCache = new Map();
+
+function createLibCachingDocumentRegistry(): ts.DocumentRegistry {
+ const localRegistry = ts.createDocumentRegistry(/*useCaseSensitiveFileNames*/ false, virtualFileSystemRoot);
+
+ function isLibFile(fileName: string): boolean {
+ return vpath.beneath(vfs.fourslashLibFolder, fileName);
+ }
+
+ return {
+ acquireDocument(fileName, compilationSettingsOrHost, scriptSnapshot, version, scriptKind, sourceFileOptions) {
+ if (isLibFile(fileName)) {
+ const cached = libSourceFileCache.get(fileName);
+ if (cached) {
+ return cached;
+ }
+ // Not cached - acquire from local registry to parse it, then cache
+ const sourceFile = localRegistry.acquireDocument(fileName, compilationSettingsOrHost, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ libSourceFileCache.set(fileName, sourceFile);
+ // Release from local registry immediately - we don't need ref counting for cached libs
+ const settings = typeof (compilationSettingsOrHost as ts.MinimalResolutionCacheHost).getCompilationSettings === "function"
+ ? (compilationSettingsOrHost as ts.MinimalResolutionCacheHost).getCompilationSettings()
+ : compilationSettingsOrHost as ts.CompilerOptions;
+ localRegistry.releaseDocument(fileName, settings, scriptKind!, typeof sourceFileOptions === "object" ? sourceFileOptions.impliedNodeFormat : undefined);
+ return sourceFile;
+ }
+ return localRegistry.acquireDocument(fileName, compilationSettingsOrHost, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ },
+ acquireDocumentWithKey(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, scriptKind, sourceFileOptions) {
+ if (isLibFile(fileName)) {
+ const cached = libSourceFileCache.get(fileName);
+ if (cached) {
+ return cached;
+ }
+ // Not cached - acquire from local registry to parse it, then cache
+ const sourceFile = localRegistry.acquireDocumentWithKey(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ libSourceFileCache.set(fileName, sourceFile);
+ // Release from local registry immediately
+ const impliedNodeFormat = typeof sourceFileOptions === "object" ? sourceFileOptions.impliedNodeFormat : undefined;
+ localRegistry.releaseDocumentWithKey(path, key, scriptKind!, impliedNodeFormat);
+ return sourceFile;
+ }
+ return localRegistry.acquireDocumentWithKey(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ },
+ updateDocument(fileName, compilationSettingsOrHost, scriptSnapshot, version, scriptKind, sourceFileOptions) {
+ if (isLibFile(fileName)) {
+ // Lib files should never be updated - just return the cached version
+ const cached = libSourceFileCache.get(fileName);
+ if (cached) {
+ return cached;
+ }
+ // Fall through to acquire if somehow not cached
+ return this.acquireDocument(fileName, compilationSettingsOrHost, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ }
+ return localRegistry.updateDocument(fileName, compilationSettingsOrHost, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ },
+ updateDocumentWithKey(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, scriptKind, sourceFileOptions) {
+ if (isLibFile(fileName)) {
+ // Lib files should never be updated - just return the cached version
+ const cached = libSourceFileCache.get(fileName);
+ if (cached) {
+ return cached;
+ }
+ // Fall through to acquire if somehow not cached
+ return this.acquireDocumentWithKey(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ }
+ return localRegistry.updateDocumentWithKey(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, scriptKind, sourceFileOptions);
+ },
+ getKeyForCompilationSettings(settings) {
+ return localRegistry.getKeyForCompilationSettings(settings);
+ },
+ getDocumentRegistryBucketKeyWithMode(key, mode) {
+ return localRegistry.getDocumentRegistryBucketKeyWithMode(key, mode);
+ },
+ releaseDocument(fileName: string, compilationSettings: ts.CompilerOptions, scriptKind?: ts.ScriptKind, impliedNodeFormat?: ts.ResolutionMode) {
+ if (isLibFile(fileName)) {
+ // Lib files are cached separately - no ref counting needed, so no-op
+ return;
+ }
+ return localRegistry.releaseDocument(fileName, compilationSettings, scriptKind!, impliedNodeFormat);
+ },
+ releaseDocumentWithKey(path: ts.Path, key: ts.DocumentRegistryBucketKey, scriptKind?: ts.ScriptKind, impliedNodeFormat?: ts.ResolutionMode) {
+ // We can't easily tell if this is a lib file from just the path without the fileName,
+ // so try to release from local registry and ignore errors
+ try {
+ localRegistry.releaseDocumentWithKey(path, key, scriptKind!, impliedNodeFormat);
+ }
+ catch {
+ // Ignore - might be a lib file that was never in the local registry
+ }
+ },
+ reportStats() {
+ return `Lib cache: ${libSourceFileCache.size} files\nLocal registry: ${localRegistry.reportStats()}`;
+ },
+ getBuckets() {
+ return localRegistry.getBuckets();
+ },
+ };
+}
+
export abstract class LanguageServiceAdapterHost {
- public readonly sys: fakes.System = new fakes.System(new vfs.FileSystem(/*ignoreCase*/ true, { cwd: virtualFileSystemRoot }));
+ public readonly sys: fakes.System;
public typesRegistry: Map | undefined;
private scriptInfos: collections.SortedMap;
public jsDocParsingMode: ts.JSDocParsingMode | undefined;
constructor(protected cancellationToken: DefaultHostCancellationToken = DefaultHostCancellationToken.instance, protected settings: ts.CompilerOptions = ts.getDefaultCompilerOptions()) {
+ this.sys = new fakes.System(createLanguageServiceVfs());
this.scriptInfos = new collections.SortedMap({ comparer: this.vfs.stringComparer, sort: "insertion" });
}
@@ -280,7 +389,7 @@ class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts
}
getDefaultLibFileName(): string {
- return Compiler.defaultLibFileName;
+ return vpath.combine(vfs.fourslashLibFolder, ts.getDefaultLibFileName(this.settings));
}
getScriptFileNames(): string[] {
@@ -289,7 +398,10 @@ class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts
getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined {
const script = this.getScriptInfo(fileName);
- return script ? new ScriptSnapshot(script) : undefined;
+ if (script) return new ScriptSnapshot(script);
+ // Fall back to reading from VFS for files not in scriptInfos (e.g., lib files)
+ const content = this.readFile(fileName);
+ return content !== undefined ? ts.ScriptSnapshot.fromString(content) : undefined;
}
getScriptKind(): ts.ScriptKind {
@@ -332,15 +444,17 @@ class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts
export class NativeLanguageServiceAdapter implements LanguageServiceAdapter {
private host: NativeLanguageServiceHost;
+ private documentRegistry: ts.DocumentRegistry;
getLogger: typeof ts.returnUndefined = ts.returnUndefined;
constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
this.host = new NativeLanguageServiceHost(cancellationToken, options);
+ this.documentRegistry = createLibCachingDocumentRegistry();
}
getHost(): LanguageServiceAdapterHost {
return this.host;
}
getLanguageService(): ts.LanguageService {
- return ts.createLanguageService(this.host);
+ return ts.createLanguageService(this.host, this.documentRegistry);
}
getClassifier(): ts.Classifier {
return ts.createClassifier();
@@ -394,8 +508,6 @@ interface ServerHostDirectoryWatcher {
cb: ts.DirectoryWatcherCallback;
}
-/** Default typescript and lib installs location for tests */
-export const harnessSessionLibLocation = "/home/src/tslibs/TS/Lib";
class SessionServerHost implements ts.server.ServerHost {
args: string[] = [];
newLine: string;
@@ -420,7 +532,9 @@ class SessionServerHost implements ts.server.ServerHost {
readFile(fileName: string): string | undefined {
// System FS would follow symlinks, even though snapshots are stored by original file name
const snapshot = this.host.getScriptSnapshot(fileName) || this.host.getScriptSnapshot(this.realpath(fileName));
- return snapshot && ts.getSnapshotText(snapshot);
+ if (snapshot) return ts.getSnapshotText(snapshot);
+ // Fall back to reading from VFS for files not in scriptInfos (e.g., lib files)
+ return this.host.readFile(fileName);
}
realpath(path: string) {
@@ -443,7 +557,7 @@ class SessionServerHost implements ts.server.ServerHost {
}
getExecutingFilePath(): string {
- return harnessSessionLibLocation + "/tsc.js";
+ return vfs.fourslashLibFolder + "/tsc.js";
}
exit = ts.noop;
@@ -671,6 +785,11 @@ export class ServerLanguageServiceAdapter implements LanguageServiceAdapter {
// or edited.
clientHost.setClient(client);
+ // Apply test options (e.g. @lib) to inferred projects
+ if (options) {
+ client.setCompilerOptionsForInferredProjects(ts.optionMapToObject(ts.serializeCompilerOptions(options)) as ts.server.protocol.CompilerOptions);
+ }
+
// Set the properties
this.client = client;
this.host = clientHost;
diff --git a/src/harness/harnessUtils.ts b/src/harness/harnessUtils.ts
index b0b0edd8af868..f768325897167 100644
--- a/src/harness/harnessUtils.ts
+++ b/src/harness/harnessUtils.ts
@@ -15,19 +15,15 @@ export function evalFile(fileContents: string, fileName: string, nodeContext?: a
}
}
-/** Splits the given string on \r\n, or on only \n if that fails, or on only \r if *that* fails. */
+const newlineRegex = /\r?\n/;
+
+/**
+ * Splits the given string on the two reasonable line terminators (\r\n or \n).
+ * Does NOT split on `\r` alone, \u2028, or \u2029.
+ */
export function splitContentByNewlines(content: string): string[] {
// Split up the input file by line
- // Note: IE JS engine incorrectly handles consecutive delimiters here when using RegExp split, so
- // we have to use string-based splitting instead and try to figure out the delimiting chars
- let lines = content.split("\r\n");
- if (lines.length === 1) {
- lines = content.split("\n");
-
- if (lines.length === 1) {
- lines = content.split("\r");
- }
- }
+ const lines = content.split(newlineRegex);
return lines;
}
diff --git a/src/harness/incrementalUtils.ts b/src/harness/incrementalUtils.ts
index 47114c88d5151..d7459f1ba489f 100644
--- a/src/harness/incrementalUtils.ts
+++ b/src/harness/incrementalUtils.ts
@@ -107,6 +107,7 @@ interface ResolutionInfo {
fileName: string;
name: string;
mode: ts.ResolutionMode;
+ watched: boolean;
}
function getResolutionCacheDetails(
@@ -254,8 +255,8 @@ export function verifyResolutionCache(
// Verify ref count
resolutionToRefs.forEach((info, resolution) => {
ts.Debug.assert(
- resolution.files?.size === info.length,
- `${projectName}:: Expected Resolution ref count ${info.length} but got ${resolution.files?.size}`,
+ (resolution.files?.size ?? 0) === info.filter(i => i.watched).length,
+ `${projectName}:: Expected Resolution ref count ${info.filter(i => i.watched).length} but got ${resolution.files?.size}`,
() =>
`Expected from:: ${JSON.stringify(info, undefined, " ")}` +
`Actual from: ${resolution.files?.size}`,
@@ -317,12 +318,13 @@ export function verifyResolutionCache(
): ExpectedResolution {
const existing = resolutionToRefs.get(resolved);
let expectedResolution: ExpectedResolution;
+ const watched = !resolutionHostCacheHost.skipWatchingFailedLookups?.(fileName);
if (existing) {
- existing.push({ cacheType, fileName, name, mode });
+ existing.push({ cacheType, fileName, name, mode, watched });
expectedResolution = resolutionToExpected.get(resolved)!;
}
else {
- resolutionToRefs.set(resolved, [{ cacheType, fileName, name, mode }]);
+ resolutionToRefs.set(resolved, [{ cacheType, fileName, name, mode, watched }]);
expectedResolution = {
resolvedModule: (resolved as any).resolvedModule,
resolvedTypeReferenceDirective: (resolved as any).resolvedTypeReferenceDirective,
@@ -333,7 +335,9 @@ export function verifyResolutionCache(
expectedToResolution.set(expectedResolution, resolved);
resolutionToExpected.set(resolved, expectedResolution);
}
- expected.watchFailedLookupLocationsOfExternalModuleResolutions(name, expectedResolution, fileName, () => ({ resolvedFileName }), deferWatchingNonRelativeResolution);
+ if (watched) {
+ expected.watchFailedLookupLocationsOfExternalModuleResolutions(name, expectedResolution, fileName, () => ({ resolvedFileName }), deferWatchingNonRelativeResolution);
+ }
return expectedResolution;
}
@@ -527,6 +531,8 @@ function verifyProgram(service: ts.server.ProjectService, project: ts.server.Pro
getGlobalTypingsCacheLocation: project.getGlobalTypingsCacheLocation.bind(project),
globalCacheResolutionModuleName: project.globalCacheResolutionModuleName.bind(project),
fileIsOpen: project.fileIsOpen.bind(project),
+ skipWatchingFailedLookups: project.skipWatchingFailedLookups.bind(project),
+ skipWatchingTypeRoots: project.skipWatchingTypeRoots.bind(project),
getCurrentProgram: () => project.getCurrentProgram(),
preferNonRecursiveWatch: project.preferNonRecursiveWatch,
diff --git a/src/harness/tsserverLogger.ts b/src/harness/tsserverLogger.ts
index 85d81ebfb217b..8f260b5304a43 100644
--- a/src/harness/tsserverLogger.ts
+++ b/src/harness/tsserverLogger.ts
@@ -1,5 +1,8 @@
import * as ts from "./_namespaces/ts.js";
-import { Compiler } from "./harnessIO.js";
+import {
+ IO,
+ libFolder,
+} from "./harnessIO.js";
export const HarnessLSCouldNotResolveModule = "HarnessLanguageService:: Could not resolve module";
@@ -142,11 +145,25 @@ function sanitizeHarnessLSException(s: string) {
return s;
}
+const libFileTextReplacements = ts.memoize(() => {
+ const replacements: { text: string; jsonText: string; replacement: string; }[] = [];
+ // Read all lib files from built/local
+ const libFiles = IO.listFiles(libFolder, /^lib.*\.d\.ts$/);
+ for (const libPath of libFiles) {
+ const content = IO.readFile(libPath);
+ if (content) {
+ const fileName = ts.getBaseFileName(libPath);
+ replacements.push({ text: content, jsonText: JSON.stringify(content), replacement: `${fileName}-Text` });
+ }
+ }
+ return replacements;
+});
+
export function sanitizeLibFileText(s: string): string {
- Compiler.libFileNameSourceFileMap?.forEach((lib, fileName) => {
- s = replaceAll(s, lib.stringified, `${fileName}-Text`);
- s = replaceAll(s, lib.file.text, `${fileName}-Text`);
- });
+ for (const { text, jsonText, replacement } of libFileTextReplacements()) {
+ s = replaceAll(s, jsonText, replacement);
+ s = replaceAll(s, text, replacement);
+ }
return s;
}
diff --git a/src/harness/vfsUtil.ts b/src/harness/vfsUtil.ts
index 596575beece2c..b217fb57bba95 100644
--- a/src/harness/vfsUtil.ts
+++ b/src/harness/vfsUtil.ts
@@ -9,6 +9,11 @@ import * as vpath from "./_namespaces/vpath.js";
*/
export const builtFolder = "/.ts";
+/**
+ * Posix-style path to libs for fourslash server tests (mounted to same location as builtFolder)
+ */
+export const fourslashLibFolder = "/home/src/tslibs/TS/Lib";
+
/**
* Posix-style path to additional mountable folders (./tests/projects in this repo)
*/
@@ -1583,6 +1588,73 @@ function getBuiltLocal(host: FileSystemResolverHost, ignoreCase: boolean): FileS
return builtLocalCS;
}
+let fourslashLibsOnlyHost: FileSystemResolverHost | undefined;
+let fourslashLibsOnlyCI: FileSystem | undefined;
+let fourslashLibsOnlyCS: FileSystem | undefined;
+
+function getFourslashLibsOnly(host: FileSystemResolverHost, ignoreCase: boolean): FileSystem {
+ if (fourslashLibsOnlyHost !== host) {
+ fourslashLibsOnlyCI = undefined;
+ fourslashLibsOnlyCS = undefined;
+ fourslashLibsOnlyHost = host;
+ }
+ if (!fourslashLibsOnlyCI) {
+ const resolver = createResolver(host);
+ fourslashLibsOnlyCI = new FileSystem(/*ignoreCase*/ true, {
+ files: {
+ [fourslashLibFolder]: new Mount(vpath.resolve(host.getWorkspaceRoot(), "built/local"), resolver),
+ },
+ cwd: "/",
+ meta: { defaultLibLocation: fourslashLibFolder },
+ });
+ fourslashLibsOnlyCI.makeReadonly();
+ }
+ if (ignoreCase) return fourslashLibsOnlyCI;
+ if (!fourslashLibsOnlyCS) {
+ fourslashLibsOnlyCS = fourslashLibsOnlyCI.shadow(/*ignoreCase*/ false);
+ fourslashLibsOnlyCS.makeReadonly();
+ }
+ return fourslashLibsOnlyCS;
+}
+
+/**
+ * Creates a VFS with only libs mounted at fourslashLibFolder, suitable for fourslash tests.
+ */
+export function createFourslashVfs(host: FileSystemResolverHost, ignoreCase: boolean, { documents, files, cwd, time, meta }: FileSystemCreateOptions = {}): FileSystem {
+ const fs = getFourslashLibsOnly(host, ignoreCase).shadow();
+ if (meta) {
+ for (const key of Object.keys(meta)) {
+ fs.meta.set(key, meta[key]);
+ }
+ }
+ if (time) {
+ fs.time(time);
+ }
+ if (cwd) {
+ fs.mkdirpSync(cwd);
+ fs.chdir(cwd);
+ }
+ if (documents) {
+ for (const document of documents) {
+ fs.mkdirpSync(vpath.dirname(document.file));
+ fs.writeFileSync(document.file, document.text, "utf8");
+ fs.filemeta(document.file).set("document", document);
+ // Add symlinks
+ const symlink = document.meta.get("symlink");
+ if (symlink) {
+ for (const link of symlink.split(",").map(link => link.trim())) {
+ fs.mkdirpSync(vpath.dirname(link));
+ fs.symlinkSync(vpath.resolve(fs.cwd(), document.file), link);
+ }
+ }
+ }
+ }
+ if (files) {
+ fs.apply(files);
+ }
+ return fs;
+}
+
/* eslint-disable no-restricted-syntax */
function normalizeFileSetEntry(value: FileSet[string]) {
if (
diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts
index d3b487d7a52c1..93b103bd8b83e 100644
--- a/src/lib/es2015.core.d.ts
+++ b/src/lib/es2015.core.d.ts
@@ -173,7 +173,7 @@ interface Math {
hypot(...values: number[]): number;
/**
- * Returns the integral part of the a numeric expression, x, removing any fractional digits.
+ * Returns the integral part of the numeric expression x, removing any fractional digits.
* If x is already an integer, the result is x.
* @param x A numeric expression.
*/
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 23f8d844c9856..aa578c7ed0815 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -80,6 +80,7 @@ import {
JSDocParsingMode,
LanguageServiceMode,
length,
+ libMap,
map,
mapDefinedIterator,
matchesExcludeWorker,
@@ -464,6 +465,10 @@ export function convertCompilerOptions(protocolOptions: protocol.ExternalProject
protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase());
}
});
+ // Convert lib short names (e.g. "es6") to full filenames (e.g. "lib.es6.d.ts")
+ if (isArray(protocolOptions.lib)) {
+ protocolOptions.lib = protocolOptions.lib.map(libName => libMap.get(libName) ?? libName);
+ }
return protocolOptions as any;
}
diff --git a/src/server/project.ts b/src/server/project.ts
index 2786ad033a3af..88fa23c1bc263 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -1530,6 +1530,15 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
/** @internal */
watchTypingLocations(files: readonly string[] | undefined): void {
+ // Skip watching typing locations for inferred project whose currentDirectory is not watchable or
+ // is same as server's current directory
+ if (
+ this.currentDirectory === this.projectService.currentDirectory ||
+ !canWatchDirectoryOrFilePath(this.toPath(this.currentDirectory))
+ ) {
+ return;
+ }
+
if (!files) {
this.typingWatchers!.isInvoked = false;
return;
@@ -1626,6 +1635,18 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
});
}
+ /** @internal */
+ skipWatchingFailedLookups(path: Path): boolean | undefined {
+ const info = this.projectService.getScriptInfoForPath(path);
+ return info?.isDynamic;
+ }
+
+ /** @internal */
+ skipWatchingTypeRoots(): boolean | undefined {
+ // Skip watching inferrd project where current directory is lib location
+ return isInferredProject(this) && this.currentDirectory === this.projectService.currentDirectory;
+ }
+
/** @internal */
getCurrentProgram(): Program | undefined {
return this.program;
diff --git a/src/testRunner/unittests/helpers/contents.ts b/src/testRunner/unittests/helpers/contents.ts
index 780ca4b1d81ee..ddfd14d5695a4 100644
--- a/src/testRunner/unittests/helpers/contents.ts
+++ b/src/testRunner/unittests/helpers/contents.ts
@@ -1,13 +1,11 @@
-import {
- harnessSessionLibLocation,
- harnessTypingInstallerCacheLocation,
-} from "../../../harness/harnessLanguageService.js";
+import * as vfs from "../../../harness/_namespaces/vfs.js";
+import { harnessTypingInstallerCacheLocation } from "../../../harness/harnessLanguageService.js";
import * as ts from "../../_namespaces/ts.js";
/** Default typescript and lib installs location for tests */
export const tscTypeScriptTestLocation: string = getPathForTypeScriptTestLocation("tsc.js");
export function getPathForTypeScriptTestLocation(fileName: string): string {
- return ts.combinePaths(harnessSessionLibLocation, fileName);
+ return ts.combinePaths(vfs.fourslashLibFolder, fileName);
}
export function getTypeScriptLibTestLocation(libName: string): string {
diff --git a/src/testRunner/unittests/helpers/monorepoSymlinkedSiblingPackages.ts b/src/testRunner/unittests/helpers/monorepoSymlinkedSiblingPackages.ts
index 2f0139f2595d3..7084298e1a72a 100644
--- a/src/testRunner/unittests/helpers/monorepoSymlinkedSiblingPackages.ts
+++ b/src/testRunner/unittests/helpers/monorepoSymlinkedSiblingPackages.ts
@@ -151,6 +151,7 @@ function getMonorepoSymlinkedSiblingPackagesSysWithUnRelatedFolders(
compilerOptions: {
outDir: "lib",
declaration: true,
+ rootDir: "src",
},
include: ["src/**/*.ts"],
}),
@@ -169,6 +170,7 @@ function getMonorepoSymlinkedSiblingPackagesSysWithUnRelatedFolders(
compilerOptions: {
outDir: "lib",
declaration: true,
+ rootDir: "src",
},
include: ["src/**/*.ts"],
}),
@@ -183,6 +185,7 @@ function getMonorepoSymlinkedSiblingPackagesSysWithUnRelatedFolders(
"/home/src/projects/b/2/b-impl/b/tsconfig.json": jsonToReadableText({
compilerOptions: {
outDir: "lib",
+ rootDir: "src",
},
include: ["src/**/*.ts"],
}),
diff --git a/src/testRunner/unittests/tsbuild/outputPaths.ts b/src/testRunner/unittests/tsbuild/outputPaths.ts
index 48007978ace8b..40a30f6e6d98a 100644
--- a/src/testRunner/unittests/tsbuild/outputPaths.ts
+++ b/src/testRunner/unittests/tsbuild/outputPaths.ts
@@ -26,7 +26,7 @@ describe("unittests:: tsbuild:: outputPaths::", () => {
...input,
});
- it("verify getOutputFileNames", () => {
+ it("verify getOutputFileNames " + input.subScenario, () => {
const sys = input.sys();
assert.deepEqual(
ts.getOutputFileNames(
@@ -58,7 +58,7 @@ describe("unittests:: tsbuild:: outputPaths::", () => {
}),
}),
edits,
- }, ["/home/src/workspaces/project/dist/index.js"]);
+ }, ["/home/src/workspaces/project/dist/src/index.js"]);
verify({
subScenario: "when rootDir is not specified and is composite",
diff --git a/src/testRunner/unittests/tsc/commandLine.ts b/src/testRunner/unittests/tsc/commandLine.ts
index d56f293f61111..fd2fe029218b7 100644
--- a/src/testRunner/unittests/tsc/commandLine.ts
+++ b/src/testRunner/unittests/tsc/commandLine.ts
@@ -30,6 +30,26 @@ describe("unittests:: tsc:: commandLine::", () => {
commandLineArgs: emptyArray,
});
+ verifyTsc({
+ scenario: "commandLine",
+ subScenario: "adds color when FORCE_COLOR is set",
+ sys: () =>
+ TestServerHost.createWatchedSystem(emptyArray, {
+ environmentVariables: new Map([["FORCE_COLOR", "true"]]),
+ }),
+ commandLineArgs: emptyArray,
+ });
+
+ verifyTsc({
+ scenario: "commandLine",
+ subScenario: "does not add color when NO_COLOR is set even if FORCE_COLOR is set",
+ sys: () =>
+ TestServerHost.createWatchedSystem(emptyArray, {
+ environmentVariables: new Map([["NO_COLOR", "true"], ["FORCE_COLOR", "true"]]),
+ }),
+ commandLineArgs: emptyArray,
+ });
+
verifyTsc({
scenario: "commandLine",
subScenario: "when build not first argument",
diff --git a/src/testRunner/unittests/tsc/projectReferences.ts b/src/testRunner/unittests/tsc/projectReferences.ts
index 3a5b1e09de7ad..39ca6ce5f71fe 100644
--- a/src/testRunner/unittests/tsc/projectReferences.ts
+++ b/src/testRunner/unittests/tsc/projectReferences.ts
@@ -90,6 +90,42 @@ describe("unittests:: tsc:: projectReferences::", () => {
commandLineArgs: ["--p", "app", "--pretty", "false"],
});
+ verifyTsc({
+ scenario: "projectReferences",
+ subScenario: "referenced project with esnext module disallows synthetic default imports",
+ sys: () =>
+ TestServerHost.createWatchedSystem({
+ "/home/src/workspaces/project/lib/tsconfig.json": jsonToReadableText({
+ compilerOptions: {
+ composite: true,
+ declaration: true,
+ module: "esnext",
+ moduleResolution: "bundler",
+ rootDir: "src",
+ outDir: "dist",
+ },
+ include: ["src"],
+ }),
+ "/home/src/workspaces/project/lib/src/utils.ts": "export const test = () => 'test';",
+ "/home/src/workspaces/project/lib/dist/utils.d.ts": "export declare const test: () => string;",
+ "/home/src/workspaces/project/app/tsconfig.json": jsonToReadableText({
+ compilerOptions: {
+ module: "esnext",
+ moduleResolution: "bundler",
+ },
+ references: [
+ { path: "../lib" },
+ ],
+ }),
+ "/home/src/workspaces/project/app/index.ts": `
+ import TestSrc from '../lib/src/utils'; // Error
+ import TestDecl from '../lib/dist/utils'; // Error
+ console.log(TestSrc.test());
+ console.log(TestDecl.test());`,
+ }),
+ commandLineArgs: ["--p", "app", "--pretty", "false"],
+ });
+
verifyTsc({
scenario: "projectReferences",
subScenario: "referencing ambient const enum from referenced project with preserveConstEnums",
diff --git a/src/testRunner/unittests/tsserver/dynamicFiles.ts b/src/testRunner/unittests/tsserver/dynamicFiles.ts
index d3d3945e19286..5a5906f08c3de 100644
--- a/src/testRunner/unittests/tsserver/dynamicFiles.ts
+++ b/src/testRunner/unittests/tsserver/dynamicFiles.ts
@@ -270,4 +270,27 @@ describe("unittests:: tsserver:: dynamicFiles:: ", () => {
verifyPathRecognizedAsDynamic("walkThroughSnippet", "walkThroughSnippet:/usr/share/code/resources/app/out/vs/workbench/contrib/welcome/walkThrough/browser/editor/^vs_code_editor_walkthrough.md#1.ts");
verifyPathRecognizedAsDynamic("untitled", "untitled:/Users/matb/projects/san/^newFile.ts");
});
+
+ it("chat block with imports", () => {
+ const host = TestServerHost.createServerHost({
+ "/user/username/projects/myproject/a.ts": "",
+ "/user/username/projects/myproject/tsconfig.json": "{}",
+ });
+ const session = new TestSession({ host, useInferredProjectPerProjectRoot: true });
+ openFilesForSession([{ file: "/user/username/projects/myproject/a.ts", projectRootPath: "/user/username/projects/myproject" }], session);
+ // Without projectRoot
+ openFilesForSession([{
+ file: "^/chat-editing-snapshot-text-model/ts-nul-authority/c/temp/codeRepo/src/services/user.service.ts",
+ content: "",
+ scriptKindName: "TS",
+ }], session);
+ // with "/" as project root
+ openFilesForSession([{
+ file: '^/vscode-chat-code-block/dnnjb2rllwnoyxqtc2vzc2lvbjovl2xvy2fsl1peag1oelv6tkdvde9uvtvnuzawtxpbnuxxstrare10tvrobfpuvtbpvgmytudwaq/response_6b1244f1-9aca-4b8b-8f65-0ff7ed4e6b4e/2#{"references":[]}',
+ content: `import { UserService from './src/services/user.service';}`,
+ projectRootPath: "/",
+ scriptKindName: "TS",
+ }], session);
+ baselineTsserverLogs("dynamicFiles", "chat block with imports", session);
+ });
});
diff --git a/tests/baselines/reference/2dArrays.js b/tests/baselines/reference/2dArrays.js
index 67ca55be5f1e1..3c12da4a25ef8 100644
--- a/tests/baselines/reference/2dArrays.js
+++ b/tests/baselines/reference/2dArrays.js
@@ -5,12 +5,12 @@ class Cell {
}
class Ship {
- isSunk: boolean;
+ isSunk: boolean = false;
}
class Board {
- ships: Ship[];
- cells: Cell[];
+ ships: Ship[] = [];
+ cells: Cell[] = [];
private allShipsSunk() {
return this.ships.every(function (val) { return val.isSunk; });
@@ -25,11 +25,14 @@ var Cell = /** @class */ (function () {
}());
var Ship = /** @class */ (function () {
function Ship() {
+ this.isSunk = false;
}
return Ship;
}());
var Board = /** @class */ (function () {
function Board() {
+ this.ships = [];
+ this.cells = [];
}
Board.prototype.allShipsSunk = function () {
return this.ships.every(function (val) { return val.isSunk; });
diff --git a/tests/baselines/reference/2dArrays.symbols b/tests/baselines/reference/2dArrays.symbols
index 3974e5e803d82..109c8307ff9fc 100644
--- a/tests/baselines/reference/2dArrays.symbols
+++ b/tests/baselines/reference/2dArrays.symbols
@@ -8,23 +8,23 @@ class Cell {
class Ship {
>Ship : Symbol(Ship, Decl(2dArrays.ts, 1, 1))
- isSunk: boolean;
+ isSunk: boolean = false;
>isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
}
class Board {
>Board : Symbol(Board, Decl(2dArrays.ts, 5, 1))
- ships: Ship[];
+ ships: Ship[] = [];
>ships : Symbol(Board.ships, Decl(2dArrays.ts, 7, 13))
>Ship : Symbol(Ship, Decl(2dArrays.ts, 1, 1))
- cells: Cell[];
->cells : Symbol(Board.cells, Decl(2dArrays.ts, 8, 18))
+ cells: Cell[] = [];
+>cells : Symbol(Board.cells, Decl(2dArrays.ts, 8, 23))
>Cell : Symbol(Cell, Decl(2dArrays.ts, 0, 0))
private allShipsSunk() {
->allShipsSunk : Symbol(Board.allShipsSunk, Decl(2dArrays.ts, 9, 18))
+>allShipsSunk : Symbol(Board.allShipsSunk, Decl(2dArrays.ts, 9, 23))
return this.ships.every(function (val) { return val.isSunk; });
>this.ships.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
diff --git a/tests/baselines/reference/2dArrays.types b/tests/baselines/reference/2dArrays.types
index 74a962fff0424..3ad88ae6b15dc 100644
--- a/tests/baselines/reference/2dArrays.types
+++ b/tests/baselines/reference/2dArrays.types
@@ -10,22 +10,28 @@ class Ship {
>Ship : Ship
> : ^^^^
- isSunk: boolean;
+ isSunk: boolean = false;
>isSunk : boolean
> : ^^^^^^^
+>false : false
+> : ^^^^^
}
class Board {
>Board : Board
> : ^^^^^
- ships: Ship[];
+ ships: Ship[] = [];
>ships : Ship[]
> : ^^^^^^
+>[] : undefined[]
+> : ^^^^^^^^^^^
- cells: Cell[];
+ cells: Cell[] = [];
>cells : Cell[]
> : ^^^^^^
+>[] : undefined[]
+> : ^^^^^^^^^^^
private allShipsSunk() {
>allShipsSunk : () => boolean
diff --git a/tests/baselines/reference/APISample_Watch.js b/tests/baselines/reference/APISample_Watch.js
index 8659e969ffb66..608d0e00a1dda 100644
--- a/tests/baselines/reference/APISample_Watch.js
+++ b/tests/baselines/reference/APISample_Watch.js
@@ -51,7 +51,7 @@ function watchMain() {
// You can technically override any given hook on the host, though you probably don't need to.
// Note that we're assuming `origCreateProgram` and `origPostProgramCreate` doesn't use `this` at all.
const origCreateProgram = host.createProgram;
- host.createProgram = (rootNames: ReadonlyArray, options, host, oldProgram) => {
+ host.createProgram = (rootNames: ReadonlyArray | undefined, options, host, oldProgram) => {
console.log("** We're about to create the program! **");
return origCreateProgram(rootNames, options, host, oldProgram);
}
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck11.errors.txt
index 0c850f5ff5499..4ccd0dc727574 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck11.errors.txt
+++ b/tests/baselines/reference/ES5For-ofTypeCheck11.errors.txt
@@ -3,7 +3,7 @@ ES5For-ofTypeCheck11.ts(3,6): error TS2322: Type 'string | number' is not assign
==== ES5For-ofTypeCheck11.ts (1 errors) ====
- var union: string | number[];
+ declare var union: string | number[];
var v: string;
for (v of union) { }
~
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.js b/tests/baselines/reference/ES5For-ofTypeCheck11.js
index a601d2f658a11..3f1e87cd7050b 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck11.js
+++ b/tests/baselines/reference/ES5For-ofTypeCheck11.js
@@ -1,12 +1,11 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts] ////
//// [ES5For-ofTypeCheck11.ts]
-var union: string | number[];
+declare var union: string | number[];
var v: string;
for (v of union) { }
//// [ES5For-ofTypeCheck11.js]
-var union;
var v;
for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
v = union_1[_i];
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.symbols b/tests/baselines/reference/ES5For-ofTypeCheck11.symbols
index 51a72d9f37362..cfdf8ac0287c6 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck11.symbols
+++ b/tests/baselines/reference/ES5For-ofTypeCheck11.symbols
@@ -1,13 +1,13 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts] ////
=== ES5For-ofTypeCheck11.ts ===
-var union: string | number[];
->union : Symbol(union, Decl(ES5For-ofTypeCheck11.ts, 0, 3))
+declare var union: string | number[];
+>union : Symbol(union, Decl(ES5For-ofTypeCheck11.ts, 0, 11))
var v: string;
>v : Symbol(v, Decl(ES5For-ofTypeCheck11.ts, 1, 3))
for (v of union) { }
>v : Symbol(v, Decl(ES5For-ofTypeCheck11.ts, 1, 3))
->union : Symbol(union, Decl(ES5For-ofTypeCheck11.ts, 0, 3))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck11.ts, 0, 11))
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.types b/tests/baselines/reference/ES5For-ofTypeCheck11.types
index 3c85a2698d2ee..f1551d5b1b1cd 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck11.types
+++ b/tests/baselines/reference/ES5For-ofTypeCheck11.types
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts] ////
=== ES5For-ofTypeCheck11.ts ===
-var union: string | number[];
+declare var union: string | number[];
>union : string | number[]
> : ^^^^^^^^^^^^^^^^^
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck14.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck14.errors.txt
index 68d5353f1a606..71d2526927a70 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck14.errors.txt
+++ b/tests/baselines/reference/ES5For-ofTypeCheck14.errors.txt
@@ -2,7 +2,7 @@ ES5For-ofTypeCheck14.ts(2,17): error TS2802: Type 'Set' can only be iter
==== ES5For-ofTypeCheck14.ts (1 errors) ====
- var union: string | Set
+ declare var union: string | Set
for (const e of union) { }
~~~~~
!!! error TS2802: Type 'Set' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck14.js b/tests/baselines/reference/ES5For-ofTypeCheck14.js
index c97179f60e279..3dd6049bc315d 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck14.js
+++ b/tests/baselines/reference/ES5For-ofTypeCheck14.js
@@ -1,11 +1,10 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck14.ts] ////
//// [ES5For-ofTypeCheck14.ts]
-var union: string | Set
+declare var union: string | Set
for (const e of union) { }
//// [ES5For-ofTypeCheck14.js]
-var union;
for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
var e = union_1[_i];
}
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck14.symbols b/tests/baselines/reference/ES5For-ofTypeCheck14.symbols
index 49354157b12a0..d964cb61ed992 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck14.symbols
+++ b/tests/baselines/reference/ES5For-ofTypeCheck14.symbols
@@ -1,11 +1,11 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck14.ts] ////
=== ES5For-ofTypeCheck14.ts ===
-var union: string | Set
->union : Symbol(union, Decl(ES5For-ofTypeCheck14.ts, 0, 3))
+declare var union: string | Set
+>union : Symbol(union, Decl(ES5For-ofTypeCheck14.ts, 0, 11))
>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
for (const e of union) { }
>e : Symbol(e, Decl(ES5For-ofTypeCheck14.ts, 1, 10))
->union : Symbol(union, Decl(ES5For-ofTypeCheck14.ts, 0, 3))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck14.ts, 0, 11))
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck14.types b/tests/baselines/reference/ES5For-ofTypeCheck14.types
index ac54cd58fb4b2..63af9b654ca59 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck14.types
+++ b/tests/baselines/reference/ES5For-ofTypeCheck14.types
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck14.ts] ////
=== ES5For-ofTypeCheck14.ts ===
-var union: string | Set
+declare var union: string | Set
>union : string | Set
> : ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck7.errors.txt
index 2b66cf9f1fedb..653f2be91661e 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck7.errors.txt
+++ b/tests/baselines/reference/ES5For-ofTypeCheck7.errors.txt
@@ -2,7 +2,7 @@ ES5For-ofTypeCheck7.ts(2,15): error TS2461: Type 'number' is not an array type.
==== ES5For-ofTypeCheck7.ts (1 errors) ====
- var union: string | number;
+ declare var union: string | number;
for (var v of union) { }
~~~~~
!!! error TS2461: Type 'number' is not an array type.
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.js b/tests/baselines/reference/ES5For-ofTypeCheck7.js
index 1fe4b50ebaeb7..517422a33ab57 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck7.js
+++ b/tests/baselines/reference/ES5For-ofTypeCheck7.js
@@ -1,11 +1,10 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck7.ts] ////
//// [ES5For-ofTypeCheck7.ts]
-var union: string | number;
+declare var union: string | number;
for (var v of union) { }
//// [ES5For-ofTypeCheck7.js]
-var union;
for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
var v = union_1[_i];
}
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.symbols b/tests/baselines/reference/ES5For-ofTypeCheck7.symbols
index f6af471545832..68dbdf6f50db5 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck7.symbols
+++ b/tests/baselines/reference/ES5For-ofTypeCheck7.symbols
@@ -1,10 +1,10 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck7.ts] ////
=== ES5For-ofTypeCheck7.ts ===
-var union: string | number;
->union : Symbol(union, Decl(ES5For-ofTypeCheck7.ts, 0, 3))
+declare var union: string | number;
+>union : Symbol(union, Decl(ES5For-ofTypeCheck7.ts, 0, 11))
for (var v of union) { }
>v : Symbol(v, Decl(ES5For-ofTypeCheck7.ts, 1, 8))
->union : Symbol(union, Decl(ES5For-ofTypeCheck7.ts, 0, 3))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck7.ts, 0, 11))
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.types b/tests/baselines/reference/ES5For-ofTypeCheck7.types
index 7901b1d185637..2a004a90d60e6 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck7.types
+++ b/tests/baselines/reference/ES5For-ofTypeCheck7.types
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck7.ts] ////
=== ES5For-ofTypeCheck7.ts ===
-var union: string | number;
+declare var union: string | number;
>union : string | number
> : ^^^^^^^^^^^^^^^
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck8.errors.txt
index 0ad1495cebc23..3f82df8f45f66 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck8.errors.txt
+++ b/tests/baselines/reference/ES5For-ofTypeCheck8.errors.txt
@@ -3,7 +3,7 @@ ES5For-ofTypeCheck8.ts(3,6): error TS2322: Type 'string | number | symbol' is no
==== ES5For-ofTypeCheck8.ts (1 errors) ====
- var union: string | string[]| number[]| symbol[];
+ declare var union: string | string[]| number[]| symbol[];
var v: symbol;
for (v of union) { }
~
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.js b/tests/baselines/reference/ES5For-ofTypeCheck8.js
index 6f126c036b4ca..04d929fbcb014 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck8.js
+++ b/tests/baselines/reference/ES5For-ofTypeCheck8.js
@@ -1,12 +1,11 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck8.ts] ////
//// [ES5For-ofTypeCheck8.ts]
-var union: string | string[]| number[]| symbol[];
+declare var union: string | string[]| number[]| symbol[];
var v: symbol;
for (v of union) { }
//// [ES5For-ofTypeCheck8.js]
-var union;
var v;
for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
v = union_1[_i];
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.symbols b/tests/baselines/reference/ES5For-ofTypeCheck8.symbols
index a73daf86cf977..faf229923b679 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck8.symbols
+++ b/tests/baselines/reference/ES5For-ofTypeCheck8.symbols
@@ -1,13 +1,13 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck8.ts] ////
=== ES5For-ofTypeCheck8.ts ===
-var union: string | string[]| number[]| symbol[];
->union : Symbol(union, Decl(ES5For-ofTypeCheck8.ts, 0, 3))
+declare var union: string | string[]| number[]| symbol[];
+>union : Symbol(union, Decl(ES5For-ofTypeCheck8.ts, 0, 11))
var v: symbol;
>v : Symbol(v, Decl(ES5For-ofTypeCheck8.ts, 1, 3))
for (v of union) { }
>v : Symbol(v, Decl(ES5For-ofTypeCheck8.ts, 1, 3))
->union : Symbol(union, Decl(ES5For-ofTypeCheck8.ts, 0, 3))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck8.ts, 0, 11))
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.types b/tests/baselines/reference/ES5For-ofTypeCheck8.types
index cbf3aececc047..4616a6fe6bae9 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck8.types
+++ b/tests/baselines/reference/ES5For-ofTypeCheck8.types
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck8.ts] ////
=== ES5For-ofTypeCheck8.ts ===
-var union: string | string[]| number[]| symbol[];
+declare var union: string | string[]| number[]| symbol[];
>union : string | string[] | number[] | symbol[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck9.errors.txt
index 681af2013de23..47f971f9d6303 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck9.errors.txt
+++ b/tests/baselines/reference/ES5For-ofTypeCheck9.errors.txt
@@ -2,7 +2,7 @@ ES5For-ofTypeCheck9.ts(2,15): error TS2461: Type 'number | symbol | string[]' is
==== ES5For-ofTypeCheck9.ts (1 errors) ====
- var union: string | string[] | number | symbol;
+ declare var union: string | string[] | number | symbol;
for (let v of union) { }
~~~~~
!!! error TS2461: Type 'number | symbol | string[]' is not an array type.
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.js b/tests/baselines/reference/ES5For-ofTypeCheck9.js
index 00667fc24d45b..fc66bb2967db7 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck9.js
+++ b/tests/baselines/reference/ES5For-ofTypeCheck9.js
@@ -1,11 +1,10 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts] ////
//// [ES5For-ofTypeCheck9.ts]
-var union: string | string[] | number | symbol;
+declare var union: string | string[] | number | symbol;
for (let v of union) { }
//// [ES5For-ofTypeCheck9.js]
-var union;
for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
var v = union_1[_i];
}
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.symbols b/tests/baselines/reference/ES5For-ofTypeCheck9.symbols
index 8e157cb7c299d..8bcf34bf7682c 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck9.symbols
+++ b/tests/baselines/reference/ES5For-ofTypeCheck9.symbols
@@ -1,10 +1,10 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts] ////
=== ES5For-ofTypeCheck9.ts ===
-var union: string | string[] | number | symbol;
->union : Symbol(union, Decl(ES5For-ofTypeCheck9.ts, 0, 3))
+declare var union: string | string[] | number | symbol;
+>union : Symbol(union, Decl(ES5For-ofTypeCheck9.ts, 0, 11))
for (let v of union) { }
>v : Symbol(v, Decl(ES5For-ofTypeCheck9.ts, 1, 8))
->union : Symbol(union, Decl(ES5For-ofTypeCheck9.ts, 0, 3))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck9.ts, 0, 11))
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.types b/tests/baselines/reference/ES5For-ofTypeCheck9.types
index 69e56c7665860..c0783320660cd 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck9.types
+++ b/tests/baselines/reference/ES5For-ofTypeCheck9.types
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts] ////
=== ES5For-ofTypeCheck9.ts ===
-var union: string | string[] | number | symbol;
+declare var union: string | string[] | number | symbol;
>union : string | number | symbol | string[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/baselines/reference/ES5SymbolProperty5.errors.txt b/tests/baselines/reference/ES5SymbolProperty5.errors.txt
index e53226f91bea4..962069c9d2a70 100644
--- a/tests/baselines/reference/ES5SymbolProperty5.errors.txt
+++ b/tests/baselines/reference/ES5SymbolProperty5.errors.txt
@@ -1,10 +1,10 @@
-ES5SymbolProperty5.ts(1,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'Symbol' must be of type 'SymbolConstructor', but here has type '{ iterator: symbol; }'.
+ES5SymbolProperty5.ts(1,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'Symbol' must be of type 'SymbolConstructor', but here has type '{ iterator: symbol; }'.
ES5SymbolProperty5.ts(7,26): error TS2554: Expected 0 arguments, but got 1.
==== ES5SymbolProperty5.ts (2 errors) ====
- var Symbol: { iterator: symbol };
- ~~~~~~
+ declare var Symbol: { iterator: symbol };
+ ~~~~~~
!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'Symbol' must be of type 'SymbolConstructor', but here has type '{ iterator: symbol; }'.
!!! related TS6203 lib.es2015.symbol.d.ts:--:--: 'Symbol' was also declared here.
diff --git a/tests/baselines/reference/ES5SymbolProperty5.js b/tests/baselines/reference/ES5SymbolProperty5.js
index b7d21bec4a0a4..45ff6b9e56199 100644
--- a/tests/baselines/reference/ES5SymbolProperty5.js
+++ b/tests/baselines/reference/ES5SymbolProperty5.js
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/Symbols/ES5SymbolProperty5.ts] ////
//// [ES5SymbolProperty5.ts]
-var Symbol: { iterator: symbol };
+declare var Symbol: { iterator: symbol };
class C {
[Symbol.iterator]() { }
@@ -10,7 +10,6 @@ class C {
(new C)[Symbol.iterator](0) // Should error
//// [ES5SymbolProperty5.js]
-var Symbol;
var C = /** @class */ (function () {
function C() {
}
diff --git a/tests/baselines/reference/ES5SymbolProperty5.symbols b/tests/baselines/reference/ES5SymbolProperty5.symbols
index 40ca8431fe20f..c0b016b14b44f 100644
--- a/tests/baselines/reference/ES5SymbolProperty5.symbols
+++ b/tests/baselines/reference/ES5SymbolProperty5.symbols
@@ -1,23 +1,23 @@
//// [tests/cases/conformance/Symbols/ES5SymbolProperty5.ts] ////
=== ES5SymbolProperty5.ts ===
-var Symbol: { iterator: symbol };
->Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(ES5SymbolProperty5.ts, 0, 3))
->iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 13))
+declare var Symbol: { iterator: symbol };
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(ES5SymbolProperty5.ts, 0, 11))
+>iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 21))
class C {
->C : Symbol(C, Decl(ES5SymbolProperty5.ts, 0, 33))
+>C : Symbol(C, Decl(ES5SymbolProperty5.ts, 0, 41))
[Symbol.iterator]() { }
>[Symbol.iterator] : Symbol(C[Symbol.iterator], Decl(ES5SymbolProperty5.ts, 2, 9))
>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(ES5SymbolProperty5.ts, 0, 3))
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(ES5SymbolProperty5.ts, 0, 11))
>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
}
(new C)[Symbol.iterator](0) // Should error
->C : Symbol(C, Decl(ES5SymbolProperty5.ts, 0, 33))
+>C : Symbol(C, Decl(ES5SymbolProperty5.ts, 0, 41))
>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(ES5SymbolProperty5.ts, 0, 3))
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(ES5SymbolProperty5.ts, 0, 11))
>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
diff --git a/tests/baselines/reference/ES5SymbolProperty5.types b/tests/baselines/reference/ES5SymbolProperty5.types
index 719789d894772..72bd530e52e21 100644
--- a/tests/baselines/reference/ES5SymbolProperty5.types
+++ b/tests/baselines/reference/ES5SymbolProperty5.types
@@ -1,7 +1,7 @@
//// [tests/cases/conformance/Symbols/ES5SymbolProperty5.ts] ////
=== ES5SymbolProperty5.ts ===
-var Symbol: { iterator: symbol };
+declare var Symbol: { iterator: symbol };
>Symbol : SymbolConstructor
> : ^^^^^^^^^^^^^^^^^
>iterator : symbol
diff --git a/tests/baselines/reference/abstractPropertyBasics.js b/tests/baselines/reference/abstractPropertyBasics.js
index c9026e5f3424d..c20a295242ff3 100644
--- a/tests/baselines/reference/abstractPropertyBasics.js
+++ b/tests/baselines/reference/abstractPropertyBasics.js
@@ -19,7 +19,7 @@ class C extends B {
set prop(v) { }
raw = "edge";
readonly ro = "readonly please";
- readonlyProp: string; // don't have to give a value, in fact
+ readonlyProp!: string;
m() { }
}
diff --git a/tests/baselines/reference/abstractPropertyBasics.symbols b/tests/baselines/reference/abstractPropertyBasics.symbols
index b7c7a74483d02..b251e283c2965 100644
--- a/tests/baselines/reference/abstractPropertyBasics.symbols
+++ b/tests/baselines/reference/abstractPropertyBasics.symbols
@@ -53,9 +53,9 @@ class C extends B {
readonly ro = "readonly please";
>ro : Symbol(C.ro, Decl(abstractPropertyBasics.ts, 16, 17))
- readonlyProp: string; // don't have to give a value, in fact
+ readonlyProp!: string;
>readonlyProp : Symbol(C.readonlyProp, Decl(abstractPropertyBasics.ts, 17, 36))
m() { }
->m : Symbol(C.m, Decl(abstractPropertyBasics.ts, 18, 25))
+>m : Symbol(C.m, Decl(abstractPropertyBasics.ts, 18, 26))
}
diff --git a/tests/baselines/reference/abstractPropertyBasics.types b/tests/baselines/reference/abstractPropertyBasics.types
index e578dfc1a3d83..c62b71a86e149 100644
--- a/tests/baselines/reference/abstractPropertyBasics.types
+++ b/tests/baselines/reference/abstractPropertyBasics.types
@@ -74,7 +74,7 @@ class C extends B {
>"readonly please" : "readonly please"
> : ^^^^^^^^^^^^^^^^^
- readonlyProp: string; // don't have to give a value, in fact
+ readonlyProp!: string;
>readonlyProp : string
> : ^^^^^^
diff --git a/tests/baselines/reference/additionOperatorWithInvalidOperands.errors.txt b/tests/baselines/reference/additionOperatorWithInvalidOperands.errors.txt
index 6051993f2e260..c1c3c7da2cde8 100644
--- a/tests/baselines/reference/additionOperatorWithInvalidOperands.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithInvalidOperands.errors.txt
@@ -28,10 +28,10 @@ additionOperatorWithInvalidOperands.ts(40,11): error TS2365: Operator '+' cannot
enum E { a, b, c }
namespace M { export var a }
- var a: boolean;
- var b: number;
- var c: Object;
- var d: Number;
+ declare var a: boolean;
+ declare var b: number;
+ declare var c: Object;
+ declare var d: Number;
// boolean + every type except any and string
var r1 = a + a;
diff --git a/tests/baselines/reference/additionOperatorWithInvalidOperands.js b/tests/baselines/reference/additionOperatorWithInvalidOperands.js
index 1093452897cef..d42f381dfd70c 100644
--- a/tests/baselines/reference/additionOperatorWithInvalidOperands.js
+++ b/tests/baselines/reference/additionOperatorWithInvalidOperands.js
@@ -9,10 +9,10 @@ class C {
enum E { a, b, c }
namespace M { export var a }
-var a: boolean;
-var b: number;
-var c: Object;
-var d: Number;
+declare var a: boolean;
+declare var b: number;
+declare var c: Object;
+declare var d: Number;
// boolean + every type except any and string
var r1 = a + a;
@@ -59,10 +59,6 @@ var E;
var M;
(function (M) {
})(M || (M = {}));
-var a;
-var b;
-var c;
-var d;
// boolean + every type except any and string
var r1 = a + a;
var r2 = a + b;
diff --git a/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols b/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols
index 697ea7cc0bbe5..4dc696b6f9247 100644
--- a/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols
+++ b/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols
@@ -23,72 +23,72 @@ namespace M { export var a }
>M : Symbol(M, Decl(additionOperatorWithInvalidOperands.ts, 5, 18))
>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 6, 24))
-var a: boolean;
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
+declare var a: boolean;
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
-var b: number;
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+declare var b: number;
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
-var c: Object;
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
+declare var c: Object;
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
-var d: Number;
->d : Symbol(d, Decl(additionOperatorWithInvalidOperands.ts, 11, 3))
+declare var d: Number;
+>d : Symbol(d, Decl(additionOperatorWithInvalidOperands.ts, 11, 11))
>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
// boolean + every type except any and string
var r1 = a + a;
>r1 : Symbol(r1, Decl(additionOperatorWithInvalidOperands.ts, 14, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
var r2 = a + b;
>r2 : Symbol(r2, Decl(additionOperatorWithInvalidOperands.ts, 15, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
var r3 = a + c;
>r3 : Symbol(r3, Decl(additionOperatorWithInvalidOperands.ts, 16, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
// number + every type except any and string
var r4 = b + a;
>r4 : Symbol(r4, Decl(additionOperatorWithInvalidOperands.ts, 19, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
var r5 = b + b; // number + number is valid
>r5 : Symbol(r5, Decl(additionOperatorWithInvalidOperands.ts, 20, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
var r6 = b + c;
>r6 : Symbol(r6, Decl(additionOperatorWithInvalidOperands.ts, 21, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
// object + every type except any and string
var r7 = c + a;
>r7 : Symbol(r7, Decl(additionOperatorWithInvalidOperands.ts, 24, 3))
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
var r8 = c + b;
>r8 : Symbol(r8, Decl(additionOperatorWithInvalidOperands.ts, 25, 3))
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
var r9 = c + c;
>r9 : Symbol(r9, Decl(additionOperatorWithInvalidOperands.ts, 26, 3))
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
->c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3))
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
+>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 11))
// other cases
var r10 = a + true;
>r10 : Symbol(r10, Decl(additionOperatorWithInvalidOperands.ts, 29, 3))
->a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 11))
var r11 = true + false;
>r11 : Symbol(r11, Decl(additionOperatorWithInvalidOperands.ts, 30, 3))
@@ -101,22 +101,22 @@ var r13 = {} + {};
var r14 = b + d;
>r14 : Symbol(r14, Decl(additionOperatorWithInvalidOperands.ts, 33, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(additionOperatorWithInvalidOperands.ts, 11, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(additionOperatorWithInvalidOperands.ts, 11, 11))
var r15 = b + foo;
>r15 : Symbol(r15, Decl(additionOperatorWithInvalidOperands.ts, 34, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
>foo : Symbol(foo, Decl(additionOperatorWithInvalidOperands.ts, 0, 0))
var r16 = b + foo();
>r16 : Symbol(r16, Decl(additionOperatorWithInvalidOperands.ts, 35, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
>foo : Symbol(foo, Decl(additionOperatorWithInvalidOperands.ts, 0, 0))
var r17 = b + C;
>r17 : Symbol(r17, Decl(additionOperatorWithInvalidOperands.ts, 36, 3))
->b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 11))
>C : Symbol(C, Decl(additionOperatorWithInvalidOperands.ts, 0, 18))
var r18 = E.a + new C();
diff --git a/tests/baselines/reference/additionOperatorWithInvalidOperands.types b/tests/baselines/reference/additionOperatorWithInvalidOperands.types
index f49e6f2b06b3d..9ed3272bad699 100644
--- a/tests/baselines/reference/additionOperatorWithInvalidOperands.types
+++ b/tests/baselines/reference/additionOperatorWithInvalidOperands.types
@@ -33,19 +33,19 @@ namespace M { export var a }
>a : any
> : ^^^
-var a: boolean;
+declare var a: boolean;
>a : boolean
> : ^^^^^^^
-var b: number;
+declare var b: number;
>b : number
> : ^^^^^^
-var c: Object;
+declare var c: Object;
>c : Object
> : ^^^^^^
-var d: Number;
+declare var d: Number;
>d : Number
> : ^^^^^^
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt
index 0a51361b10848..30c26aace1a40 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt
@@ -16,10 +16,10 @@ additionOperatorWithNullValueAndInvalidOperator.ts(23,11): error TS2365: Operato
function foo(): void { return undefined }
- var a: boolean;
- var b: Object;
- var c: void;
- var d: Number;
+ declare var a: boolean;
+ declare var b: Object;
+ declare var c: void;
+ declare var d: Number;
// null + boolean/Object
var r1 = null + a;
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.js b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.js
index 8388dbebb3955..6a38d10bd00aa 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.js
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.js
@@ -5,10 +5,10 @@
function foo(): void { return undefined }
-var a: boolean;
-var b: Object;
-var c: void;
-var d: Number;
+declare var a: boolean;
+declare var b: Object;
+declare var c: void;
+declare var d: Number;
// null + boolean/Object
var r1 = null + a;
@@ -28,10 +28,6 @@ var r11 = null + (() => { });
//// [additionOperatorWithNullValueAndInvalidOperator.js]
// If one operand is the null or undefined value, it is treated as having the type of the other operand.
function foo() { return undefined; }
-var a;
-var b;
-var c;
-var d;
// null + boolean/Object
var r1 = null + a;
var r2 = null + b;
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols
index 4e0844055bb5e..405bbe72a0b2d 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols
@@ -7,49 +7,49 @@ function foo(): void { return undefined }
>foo : Symbol(foo, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 0, 0))
>undefined : Symbol(undefined)
-var a: boolean;
->a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 3))
+declare var a: boolean;
+>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 11))
-var b: Object;
->b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 3))
+declare var b: Object;
+>b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 11))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
-var c: void;
->c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 3))
+declare var c: void;
+>c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 11))
-var d: Number;
->d : Symbol(d, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 7, 3))
+declare var d: Number;
+>d : Symbol(d, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 7, 11))
>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
// null + boolean/Object
var r1 = null + a;
>r1 : Symbol(r1, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 10, 3))
->a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 11))
var r2 = null + b;
>r2 : Symbol(r2, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 11, 3))
->b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 11))
var r3 = null + c;
>r3 : Symbol(r3, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 12, 3))
->c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 11))
var r4 = a + null;
>r4 : Symbol(r4, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 13, 3))
->a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 11))
var r5 = b + null;
>r5 : Symbol(r5, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 14, 3))
->b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 11))
var r6 = null + c;
>r6 : Symbol(r6, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 15, 3))
->c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 11))
// other cases
var r7 = null + d;
>r7 : Symbol(r7, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 18, 3))
->d : Symbol(d, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 7, 3))
+>d : Symbol(d, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 7, 11))
var r8 = null + true;
>r8 : Symbol(r8, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 19, 3))
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types
index ee664f35f3f92..cb4b2660b74a3 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types
@@ -9,19 +9,19 @@ function foo(): void { return undefined }
>undefined : undefined
> : ^^^^^^^^^
-var a: boolean;
+declare var a: boolean;
>a : boolean
> : ^^^^^^^
-var b: Object;
+declare var b: Object;
>b : Object
> : ^^^^^^
-var c: void;
+declare var c: void;
>c : void
> : ^^^^
-var d: Number;
+declare var d: Number;
>d : Number
> : ^^^^^^
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt
index eb13ff16ed092..a046d0f0b0f8f 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt
@@ -15,10 +15,10 @@ additionOperatorWithNullValueAndValidOperator.ts(24,11): error TS2365: Operator
enum E { a, b, c }
- var a: any;
- var b: number;
- var c: E;
- var d: string;
+ declare var a: any;
+ declare var b: number;
+ declare var c: E;
+ declare var d: string;
// null + any
var r1: any = null + a;
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js
index 460b5eb5fc358..0c9c6750982ed 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js
@@ -5,10 +5,10 @@
enum E { a, b, c }
-var a: any;
-var b: number;
-var c: E;
-var d: string;
+declare var a: any;
+declare var b: number;
+declare var c: E;
+declare var d: string;
// null + any
var r1: any = null + a;
@@ -40,10 +40,6 @@ var E;
E[E["b"] = 1] = "b";
E[E["c"] = 2] = "c";
})(E || (E = {}));
-var a;
-var b;
-var c;
-var d;
// null + any
var r1 = null + a;
var r2 = a + null;
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.symbols b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.symbols
index 416e99c767155..d539264fd1743 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.symbols
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.symbols
@@ -9,39 +9,39 @@ enum E { a, b, c }
>b : Symbol(E.b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 11))
>c : Symbol(E.c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 14))
-var a: any;
->a : Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 3))
+declare var a: any;
+>a : Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 11))
-var b: number;
->b : Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 3))
+declare var b: number;
+>b : Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 11))
-var c: E;
->c : Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 3))
+declare var c: E;
+>c : Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 11))
>E : Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
-var d: string;
->d : Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 3))
+declare var d: string;
+>d : Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 11))
// null + any
var r1: any = null + a;
>r1 : Symbol(r1, Decl(additionOperatorWithNullValueAndValidOperator.ts, 10, 3))
->a : Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 11))
var r2: any = a + null;
>r2 : Symbol(r2, Decl(additionOperatorWithNullValueAndValidOperator.ts, 11, 3))
->a : Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 11))
// null + number/enum
var r3 = null + b;
>r3 : Symbol(r3, Decl(additionOperatorWithNullValueAndValidOperator.ts, 14, 3))
->b : Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 11))
var r4 = null + 1;
>r4 : Symbol(r4, Decl(additionOperatorWithNullValueAndValidOperator.ts, 15, 3))
var r5 = null + c;
>r5 : Symbol(r5, Decl(additionOperatorWithNullValueAndValidOperator.ts, 16, 3))
->c : Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 11))
var r6 = null + E.a;
>r6 : Symbol(r6, Decl(additionOperatorWithNullValueAndValidOperator.ts, 17, 3))
@@ -56,14 +56,14 @@ var r7 = null + E['a'];
var r8 = b + null;
>r8 : Symbol(r8, Decl(additionOperatorWithNullValueAndValidOperator.ts, 19, 3))
->b : Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 11))
var r9 = 1 + null;
>r9 : Symbol(r9, Decl(additionOperatorWithNullValueAndValidOperator.ts, 20, 3))
var r10 = c + null
>r10 : Symbol(r10, Decl(additionOperatorWithNullValueAndValidOperator.ts, 21, 3))
->c : Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 11))
var r11 = E.a + null;
>r11 : Symbol(r11, Decl(additionOperatorWithNullValueAndValidOperator.ts, 22, 3))
@@ -79,14 +79,14 @@ var r12 = E['a'] + null;
// null + string
var r13 = null + d;
>r13 : Symbol(r13, Decl(additionOperatorWithNullValueAndValidOperator.ts, 26, 3))
->d : Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 3))
+>d : Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 11))
var r14 = null + '';
>r14 : Symbol(r14, Decl(additionOperatorWithNullValueAndValidOperator.ts, 27, 3))
var r15 = d + null;
>r15 : Symbol(r15, Decl(additionOperatorWithNullValueAndValidOperator.ts, 28, 3))
->d : Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 3))
+>d : Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 11))
var r16 = '' + null;
>r16 : Symbol(r16, Decl(additionOperatorWithNullValueAndValidOperator.ts, 29, 3))
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types
index b2e3a1b34d6a4..59be50dfa81fb 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types
@@ -13,19 +13,19 @@ enum E { a, b, c }
>c : E.c
> : ^^^
-var a: any;
+declare var a: any;
>a : any
> : ^^^
-var b: number;
+declare var b: number;
>b : number
> : ^^^^^^
-var c: E;
+declare var c: E;
>c : E
> : ^
-var d: string;
+declare var d: string;
>d : string
> : ^^^^^^
diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt b/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt
index 42e6850300c75..6bf776b120d4b 100644
--- a/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt
@@ -21,13 +21,13 @@ additionOperatorWithTypeParameter.ts(37,15): error TS2365: Operator '+' cannot b
enum E { a, b }
function foo(t: T, u: U) {
- var a: any;
- var b: boolean;
- var c: number;
- var d: string;
- var e: Object;
- var g: E;
- var f: void;
+ let a!: any;
+ let b!: boolean;
+ let c!: number;
+ let d!: string;
+ let e!: Object;
+ let g!: E;
+ let f!: void;
// type parameter as left operand
var r1: any = t + a; // ok, one operand is any
diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.js b/tests/baselines/reference/additionOperatorWithTypeParameter.js
index 7f321c748aeb0..aaf8c9d72d9b2 100644
--- a/tests/baselines/reference/additionOperatorWithTypeParameter.js
+++ b/tests/baselines/reference/additionOperatorWithTypeParameter.js
@@ -5,13 +5,13 @@
enum E { a, b }
function foo(t: T, u: U) {
- var a: any;
- var b: boolean;
- var c: number;
- var d: string;
- var e: Object;
- var g: E;
- var f: void;
+ let a!: any;
+ let b!: boolean;
+ let c!: number;
+ let d!: string;
+ let e!: Object;
+ let g!: E;
+ let f!: void;
// type parameter as left operand
var r1: any = t + a; // ok, one operand is any
diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.symbols b/tests/baselines/reference/additionOperatorWithTypeParameter.symbols
index 4b765c129d755..70ed83db31ebc 100644
--- a/tests/baselines/reference/additionOperatorWithTypeParameter.symbols
+++ b/tests/baselines/reference/additionOperatorWithTypeParameter.symbols
@@ -16,27 +16,27 @@ function foo(t: T, u: U) {
>u : Symbol(u, Decl(additionOperatorWithTypeParameter.ts, 3, 24))
>U : Symbol(U, Decl(additionOperatorWithTypeParameter.ts, 3, 15))
- var a: any;
+ let a!: any;
>a : Symbol(a, Decl(additionOperatorWithTypeParameter.ts, 4, 7))
- var b: boolean;
+ let b!: boolean;
>b : Symbol(b, Decl(additionOperatorWithTypeParameter.ts, 5, 7))
- var c: number;
+ let c!: number;
>c : Symbol(c, Decl(additionOperatorWithTypeParameter.ts, 6, 7))
- var d: string;
+ let d!: string;
>d : Symbol(d, Decl(additionOperatorWithTypeParameter.ts, 7, 7))
- var e: Object;
+ let e!: Object;
>e : Symbol(e, Decl(additionOperatorWithTypeParameter.ts, 8, 7))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
- var g: E;
+ let g!: E;
>g : Symbol(g, Decl(additionOperatorWithTypeParameter.ts, 9, 7))
>E : Symbol(E, Decl(additionOperatorWithTypeParameter.ts, 0, 0))
- var f: void;
+ let f!: void;
>f : Symbol(f, Decl(additionOperatorWithTypeParameter.ts, 10, 7))
// type parameter as left operand
diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.types b/tests/baselines/reference/additionOperatorWithTypeParameter.types
index 5291fc2fe0e57..200f1ebab23a1 100644
--- a/tests/baselines/reference/additionOperatorWithTypeParameter.types
+++ b/tests/baselines/reference/additionOperatorWithTypeParameter.types
@@ -18,31 +18,31 @@ function foo(t: T, u: U) {
>u : U
> : ^
- var a: any;
+ let a!: any;
>a : any
> : ^^^
- var b: boolean;
+ let b!: boolean;
>b : boolean
> : ^^^^^^^
- var c: number;
+ let c!: number;
>c : number
> : ^^^^^^
- var d: string;
+ let d!: string;
>d : string
> : ^^^^^^
- var e: Object;
+ let e!: Object;
>e : Object
> : ^^^^^^
- var g: E;
+ let g!: E;
>g : E
> : ^
- var f: void;
+ let f!: void;
>f : void
> : ^^^^
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt
index 7546a67f9f332..1c50937aad0a7 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt
@@ -16,10 +16,10 @@ additionOperatorWithUndefinedValueAndInvalidOperands.ts(23,11): error TS2365: Op
function foo(): void { return undefined }
- var a: boolean;
- var b: Object;
- var c: void;
- var d: Number;
+ declare var a: boolean;
+ declare var b: Object;
+ declare var c: void;
+ declare var d: Number;
// undefined + boolean/Object
var r1 = undefined + a;
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.js b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.js
index 755ddc7bc18e3..c4d1cafd628d3 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.js
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.js
@@ -5,10 +5,10 @@
function foo(): void { return undefined }
-var a: boolean;
-var b: Object;
-var c: void;
-var d: Number;
+declare var a: boolean;
+declare var b: Object;
+declare var c: void;
+declare var d: Number;
// undefined + boolean/Object
var r1 = undefined + a;
@@ -28,10 +28,6 @@ var r11 = undefined + (() => { });
//// [additionOperatorWithUndefinedValueAndInvalidOperands.js]
// If one operand is the null or undefined value, it is treated as having the type of the other operand.
function foo() { return undefined; }
-var a;
-var b;
-var c;
-var d;
// undefined + boolean/Object
var r1 = undefined + a;
var r2 = undefined + b;
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols
index 0ea20fccc4a65..b6fc78b177ea4 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols
@@ -7,56 +7,56 @@ function foo(): void { return undefined }
>foo : Symbol(foo, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 0, 0))
>undefined : Symbol(undefined)
-var a: boolean;
->a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+declare var a: boolean;
+>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
-var b: Object;
->b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+declare var b: Object;
+>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
-var c: void;
->c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 3))
+declare var c: void;
+>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 11))
-var d: Number;
->d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 7, 3))
+declare var d: Number;
+>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 7, 11))
>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
// undefined + boolean/Object
var r1 = undefined + a;
>r1 : Symbol(r1, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 10, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r2 = undefined + b;
>r2 : Symbol(r2, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 11, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r3 = undefined + c;
>r3 : Symbol(r3, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 12, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 11))
var r4 = a + undefined;
>r4 : Symbol(r4, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 13, 3))
->a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r5 = b + undefined;
>r5 : Symbol(r5, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 14, 3))
->b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r6 = undefined + c;
>r6 : Symbol(r6, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 15, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 11))
// other cases
var r7 = undefined + d;
>r7 : Symbol(r7, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 18, 3))
>undefined : Symbol(undefined)
->d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 7, 11))
var r8 = undefined + true;
>r8 : Symbol(r8, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 19, 3))
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types
index d9bf840aa0695..39fc32e765ba8 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types
@@ -9,19 +9,19 @@ function foo(): void { return undefined }
>undefined : undefined
> : ^^^^^^^^^
-var a: boolean;
+declare var a: boolean;
>a : boolean
> : ^^^^^^^
-var b: Object;
+declare var b: Object;
>b : Object
> : ^^^^^^
-var c: void;
+declare var c: void;
>c : void
> : ^^^^
-var d: Number;
+declare var d: Number;
>d : Number
> : ^^^^^^
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt
index 36a4ce620cb5a..bf1f4cd3e4fd3 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt
@@ -15,10 +15,10 @@ additionOperatorWithUndefinedValueAndValidOperator.ts(24,11): error TS2365: Oper
enum E { a, b, c }
- var a: any;
- var b: number;
- var c: E;
- var d: string;
+ declare var a: any;
+ declare var b: number;
+ declare var c: E;
+ declare var d: string;
// undefined + any
var r1: any = undefined + a;
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js
index bff58795e7683..f80fb1253c3f4 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js
@@ -5,10 +5,10 @@
enum E { a, b, c }
-var a: any;
-var b: number;
-var c: E;
-var d: string;
+declare var a: any;
+declare var b: number;
+declare var c: E;
+declare var d: string;
// undefined + any
var r1: any = undefined + a;
@@ -40,10 +40,6 @@ var E;
E[E["b"] = 1] = "b";
E[E["c"] = 2] = "c";
})(E || (E = {}));
-var a;
-var b;
-var c;
-var d;
// undefined + any
var r1 = undefined + a;
var r2 = a + undefined;
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.symbols b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.symbols
index a45dfe9f559b6..55cd1d2e95ace 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.symbols
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.symbols
@@ -9,35 +9,35 @@ enum E { a, b, c }
>b : Symbol(E.b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 11))
>c : Symbol(E.c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 14))
-var a: any;
->a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 3))
+declare var a: any;
+>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 11))
-var b: number;
->b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 3))
+declare var b: number;
+>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 11))
-var c: E;
->c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 3))
+declare var c: E;
+>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 11))
>E : Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
-var d: string;
->d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 3))
+declare var d: string;
+>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 11))
// undefined + any
var r1: any = undefined + a;
>r1 : Symbol(r1, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 10, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 11))
var r2: any = a + undefined;
>r2 : Symbol(r2, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 11, 3))
->a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 3))
+>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 11))
>undefined : Symbol(undefined)
// undefined + number/enum
var r3 = undefined + b;
>r3 : Symbol(r3, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 14, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 11))
var r4 = undefined + 1;
>r4 : Symbol(r4, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 15, 3))
@@ -46,7 +46,7 @@ var r4 = undefined + 1;
var r5 = undefined + c;
>r5 : Symbol(r5, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 16, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 11))
var r6 = undefined + E.a;
>r6 : Symbol(r6, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 17, 3))
@@ -63,7 +63,7 @@ var r7 = undefined + E['a'];
var r8 = b + undefined;
>r8 : Symbol(r8, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 19, 3))
->b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 3))
+>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 11))
>undefined : Symbol(undefined)
var r9 = 1 + undefined;
@@ -72,7 +72,7 @@ var r9 = 1 + undefined;
var r10 = c + undefined
>r10 : Symbol(r10, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 21, 3))
->c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 3))
+>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 11))
>undefined : Symbol(undefined)
var r11 = E.a + undefined;
@@ -92,7 +92,7 @@ var r12 = E['a'] + undefined;
var r13 = undefined + d;
>r13 : Symbol(r13, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 26, 3))
>undefined : Symbol(undefined)
->d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 3))
+>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 11))
var r14 = undefined + '';
>r14 : Symbol(r14, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 27, 3))
@@ -100,7 +100,7 @@ var r14 = undefined + '';
var r15 = d + undefined;
>r15 : Symbol(r15, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 28, 3))
->d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 3))
+>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 11))
>undefined : Symbol(undefined)
var r16 = '' + undefined;
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types
index 5f36bcdc37951..3c87e85c3bded 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types
@@ -13,19 +13,19 @@ enum E { a, b, c }
>c : E.c
> : ^^^
-var a: any;
+declare var a: any;
>a : any
> : ^^^
-var b: number;
+declare var b: number;
>b : number
> : ^^^^^^
-var c: E;
+declare var c: E;
>c : E
> : ^
-var d: string;
+declare var d: string;
>d : string
> : ^^^^^^
diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt
index 327faccff8a54..cd328111bba70 100644
--- a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt
+++ b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt
@@ -4,7 +4,7 @@ aliasOnMergedModuleInterface_1.ts(5,16): error TS2708: Cannot use namespace 'foo
==== aliasOnMergedModuleInterface_1.ts (1 errors) ====
///
import foo = require("foo")
- var z: foo;
+ declare var z: foo;
z.bar("hello"); // This should be ok
var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
~~~
diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.js b/tests/baselines/reference/aliasOnMergedModuleInterface.js
index e7cac961b653a..3d032add8eb62 100644
--- a/tests/baselines/reference/aliasOnMergedModuleInterface.js
+++ b/tests/baselines/reference/aliasOnMergedModuleInterface.js
@@ -16,7 +16,7 @@ declare module "foo"
//// [aliasOnMergedModuleInterface_1.ts]
///
import foo = require("foo")
-var z: foo;
+declare var z: foo;
z.bar("hello"); // This should be ok
var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
@@ -25,6 +25,5 @@ var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be err
//// [aliasOnMergedModuleInterface_1.js]
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var z;
z.bar("hello"); // This should be ok
var x = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.symbols b/tests/baselines/reference/aliasOnMergedModuleInterface.symbols
index 6544197e32e71..16f71fc1185ff 100644
--- a/tests/baselines/reference/aliasOnMergedModuleInterface.symbols
+++ b/tests/baselines/reference/aliasOnMergedModuleInterface.symbols
@@ -5,13 +5,13 @@
import foo = require("foo")
>foo : Symbol(foo, Decl(aliasOnMergedModuleInterface_1.ts, 0, 0))
-var z: foo;
->z : Symbol(z, Decl(aliasOnMergedModuleInterface_1.ts, 2, 3))
+declare var z: foo;
+>z : Symbol(z, Decl(aliasOnMergedModuleInterface_1.ts, 2, 11))
>foo : Symbol(foo, Decl(aliasOnMergedModuleInterface_1.ts, 0, 0))
z.bar("hello"); // This should be ok
>z.bar : Symbol(foo.bar, Decl(aliasOnMergedModuleInterface_0.ts, 6, 17))
->z : Symbol(z, Decl(aliasOnMergedModuleInterface_1.ts, 2, 3))
+>z : Symbol(z, Decl(aliasOnMergedModuleInterface_1.ts, 2, 11))
>bar : Symbol(foo.bar, Decl(aliasOnMergedModuleInterface_0.ts, 6, 17))
var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.types b/tests/baselines/reference/aliasOnMergedModuleInterface.types
index 756caf50f4beb..08d42e1f8ed53 100644
--- a/tests/baselines/reference/aliasOnMergedModuleInterface.types
+++ b/tests/baselines/reference/aliasOnMergedModuleInterface.types
@@ -6,7 +6,7 @@ import foo = require("foo")
>foo : any
> : ^^^
-var z: foo;
+declare var z: foo;
>z : foo
> : ^^^
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.errors.txt b/tests/baselines/reference/aliasUsageInOrExpression.errors.txt
index 2ac162439c2c7..85113b6a55d79 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.errors.txt
+++ b/tests/baselines/reference/aliasUsageInOrExpression.errors.txt
@@ -8,7 +8,7 @@ aliasUsageInOrExpression_main.ts(11,40): error TS2873: This kind of expression i
interface IHasVisualizationModel {
VisualizationModel: typeof Backbone.Model;
}
- var i: IHasVisualizationModel;
+ declare var i: IHasVisualizationModel;
var d1 = i || moduleA;
var d2: IHasVisualizationModel = i || moduleA;
var d2: IHasVisualizationModel = moduleA || i;
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.js b/tests/baselines/reference/aliasUsageInOrExpression.js
index 63f9cade8fef1..25545e99de318 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.js
+++ b/tests/baselines/reference/aliasUsageInOrExpression.js
@@ -17,7 +17,7 @@ import moduleA = require("./aliasUsageInOrExpression_moduleA");
interface IHasVisualizationModel {
VisualizationModel: typeof Backbone.Model;
}
-var i: IHasVisualizationModel;
+declare var i: IHasVisualizationModel;
var d1 = i || moduleA;
var d2: IHasVisualizationModel = i || moduleA;
var d2: IHasVisualizationModel = moduleA || i;
@@ -66,7 +66,6 @@ exports.VisualizationModel = VisualizationModel;
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var moduleA = require("./aliasUsageInOrExpression_moduleA");
-var i;
var d1 = i || moduleA;
var d2 = i || moduleA;
var d2 = moduleA || i;
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.symbols b/tests/baselines/reference/aliasUsageInOrExpression.symbols
index 8c56640fb27a2..6cb0647c087df 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.symbols
+++ b/tests/baselines/reference/aliasUsageInOrExpression.symbols
@@ -16,26 +16,26 @@ interface IHasVisualizationModel {
>Backbone : Symbol(Backbone, Decl(aliasUsageInOrExpression_main.ts, 0, 0))
>Model : Symbol(Backbone.Model, Decl(aliasUsageInOrExpression_backbone.ts, 0, 0))
}
-var i: IHasVisualizationModel;
->i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
+declare var i: IHasVisualizationModel;
+>i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 11))
>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
var d1 = i || moduleA;
>d1 : Symbol(d1, Decl(aliasUsageInOrExpression_main.ts, 6, 3))
->i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
+>i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 11))
>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
var d2: IHasVisualizationModel = i || moduleA;
>d2 : Symbol(d2, Decl(aliasUsageInOrExpression_main.ts, 7, 3), Decl(aliasUsageInOrExpression_main.ts, 8, 3))
>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
->i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
+>i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 11))
>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
var d2: IHasVisualizationModel = moduleA || i;
>d2 : Symbol(d2, Decl(aliasUsageInOrExpression_main.ts, 7, 3), Decl(aliasUsageInOrExpression_main.ts, 8, 3))
>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
->i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
+>i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 11))
var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
>e : Symbol(e, Decl(aliasUsageInOrExpression_main.ts, 9, 3))
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.types b/tests/baselines/reference/aliasUsageInOrExpression.types
index f79acc30c5c75..ab24f27750295 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.types
+++ b/tests/baselines/reference/aliasUsageInOrExpression.types
@@ -20,7 +20,7 @@ interface IHasVisualizationModel {
>Model : typeof Backbone.Model
> : ^^^^^^^^^^^^^^^^^^^^^
}
-var i: IHasVisualizationModel;
+declare var i: IHasVisualizationModel;
>i : IHasVisualizationModel
> : ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/baselines/reference/alwaysStrictModule2.errors.txt b/tests/baselines/reference/alwaysStrictModule2.errors.txt
index d1302f9c0c5f0..9f15368183c0a 100644
--- a/tests/baselines/reference/alwaysStrictModule2.errors.txt
+++ b/tests/baselines/reference/alwaysStrictModule2.errors.txt
@@ -1,7 +1,9 @@
+error TS5101: Option 'outFile' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
a.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode.
b.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode.
+!!! error TS5101: Option 'outFile' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
==== a.ts (1 errors) ====
namespace M {
export function f() {
diff --git a/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.errors.txt b/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.errors.txt
index 3e48ae27ac125..b78698d948e8a 100644
--- a/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.errors.txt
+++ b/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.errors.txt
@@ -1,6 +1,8 @@
+error TS5101: Option 'outFile' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
error TS5107: Option 'module=AMD' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
+!!! error TS5101: Option 'outFile' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
!!! error TS5107: Option 'module=AMD' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
==== Class.ts (0 errors) ====
import { Configurable } from "./Configurable"
diff --git a/tests/baselines/reference/amdModuleBundleNoDuplicateDeclarationEmitComments.errors.txt b/tests/baselines/reference/amdModuleBundleNoDuplicateDeclarationEmitComments.errors.txt
index a0f10142a0010..c4877ef823505 100644
--- a/tests/baselines/reference/amdModuleBundleNoDuplicateDeclarationEmitComments.errors.txt
+++ b/tests/baselines/reference/amdModuleBundleNoDuplicateDeclarationEmitComments.errors.txt
@@ -1,6 +1,8 @@
+error TS5101: Option 'outFile' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
error TS5107: Option 'module=AMD' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
+!!! error TS5101: Option 'outFile' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
!!! error TS5107: Option 'module=AMD' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
==== file1.ts (0 errors) ====
///
diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.errors.txt
index 7fe239623fa97..8f7727381f762 100644
--- a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.errors.txt
@@ -562,12 +562,12 @@ arithmeticOperatorWithInvalidOperands.ts(581,13): error TS2362: The left-hand si
// an enum type
enum E { a, b, c }
- var a: any;
- var b: boolean;
- var c: number;
- var d: string;
- var e: { a: number };
- var f: Number;
+ declare var a: any;
+ declare var b: boolean;
+ declare var c: number;
+ declare var d: string;
+ declare var e: { a: number };
+ declare var f: Number;
// All of the below should be an error unless otherwise noted
// operator *
diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js
index 691081b53722b..e8a6cfa93d418 100644
--- a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js
@@ -5,12 +5,12 @@
// an enum type
enum E { a, b, c }
-var a: any;
-var b: boolean;
-var c: number;
-var d: string;
-var e: { a: number };
-var f: Number;
+declare var a: any;
+declare var b: boolean;
+declare var c: number;
+declare var d: string;
+declare var e: { a: number };
+declare var f: Number;
// All of the below should be an error unless otherwise noted
// operator *
@@ -592,12 +592,6 @@ var E;
E[E["b"] = 1] = "b";
E[E["c"] = 2] = "c";
})(E || (E = {}));
-var a;
-var b;
-var c;
-var d;
-var e;
-var f;
// All of the below should be an error unless otherwise noted
// operator *
var r1a1 = a * a; //ok
diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols
index b087cff2b360d..59697e9684c70 100644
--- a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols
+++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols
@@ -9,288 +9,288 @@ enum E { a, b, c }
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>c : Symbol(E.c, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 14))
-var a: any;
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+declare var a: any;
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
-var b: boolean;
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+declare var b: boolean;
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
-var c: number;
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+declare var c: number;
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
-var d: string;
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+declare var d: string;
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
-var e: { a: number };
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 8))
+declare var e: { a: number };
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 16))
-var f: Number;
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+declare var f: Number;
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
// All of the below should be an error unless otherwise noted
// operator *
var r1a1 = a * a; //ok
>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 13, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1a2 = a * b;
>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 14, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1a3 = a * c; //ok
>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 15, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1a4 = a * d;
>r1a4 : Symbol(r1a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 16, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1a5 = a * e;
>r1a5 : Symbol(r1a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 17, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1a6 = a * f;
>r1a6 : Symbol(r1a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 18, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1b1 = b * a;
>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 20, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1b2 = b * b;
>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 21, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1b3 = b * c;
>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 22, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1b4 = b * d;
>r1b4 : Symbol(r1b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 23, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1b5 = b * e;
>r1b5 : Symbol(r1b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 24, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1b6 = b * f;
>r1b6 : Symbol(r1b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 25, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1c1 = c * a; //ok
>r1c1 : Symbol(r1c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 27, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1c2 = c * b;
>r1c2 : Symbol(r1c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 28, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1c3 = c * c; //ok
>r1c3 : Symbol(r1c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 29, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1c4 = c * d;
>r1c4 : Symbol(r1c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 30, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1c5 = c * e;
>r1c5 : Symbol(r1c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 31, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1c6 = c * f;
>r1c6 : Symbol(r1c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 32, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1d1 = d * a;
>r1d1 : Symbol(r1d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 34, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1d2 = d * b;
>r1d2 : Symbol(r1d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 35, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1d3 = d * c;
>r1d3 : Symbol(r1d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 36, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1d4 = d * d;
>r1d4 : Symbol(r1d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 37, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1d5 = d * e;
>r1d5 : Symbol(r1d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 38, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1d6 = d * f;
>r1d6 : Symbol(r1d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 39, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1e1 = e * a;
>r1e1 : Symbol(r1e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 41, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1e2 = e * b;
>r1e2 : Symbol(r1e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 42, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1e3 = e * c;
>r1e3 : Symbol(r1e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 43, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1e4 = e * d;
>r1e4 : Symbol(r1e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 44, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1e5 = e * e;
>r1e5 : Symbol(r1e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 45, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1e6 = e * f;
>r1e6 : Symbol(r1e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 46, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1f1 = f * a;
>r1f1 : Symbol(r1f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 48, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1f2 = f * b;
>r1f2 : Symbol(r1f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 49, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1f3 = f * c;
>r1f3 : Symbol(r1f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 50, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1f4 = f * d;
>r1f4 : Symbol(r1f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 51, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1f5 = f * e;
>r1f5 : Symbol(r1f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 52, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1f6 = f * f;
>r1f6 : Symbol(r1f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 53, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1g1 = E.a * a; //ok
>r1g1 : Symbol(r1g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 55, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r1g2 = E.a * b;
>r1g2 : Symbol(r1g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 56, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r1g3 = E.a * c; //ok
>r1g3 : Symbol(r1g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 57, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r1g4 = E.a * d;
>r1g4 : Symbol(r1g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 58, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r1g5 = E.a * e;
>r1g5 : Symbol(r1g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 59, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r1g6 = E.a * f;
>r1g6 : Symbol(r1g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 60, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r1h1 = a * E.b; //ok
>r1h1 : Symbol(r1h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 62, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r1h2 = b * E.b;
>r1h2 : Symbol(r1h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 63, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r1h3 = c * E.b; //ok
>r1h3 : Symbol(r1h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 64, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r1h4 = d * E.b;
>r1h4 : Symbol(r1h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 65, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r1h5 = e * E.b;
>r1h5 : Symbol(r1h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 66, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r1h6 = f * E.b;
>r1h6 : Symbol(r1h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 67, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -298,264 +298,264 @@ var r1h6 = f * E.b;
// operator /
var r2a1 = a / a; //ok
>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 70, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2a2 = a / b;
>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 71, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2a3 = a / c; //ok
>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 72, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2a4 = a / d;
>r2a4 : Symbol(r2a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 73, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2a5 = a / e;
>r2a5 : Symbol(r2a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 74, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2a6 = a / f;
>r2a6 : Symbol(r2a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 75, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2b1 = b / a;
>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 77, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2b2 = b / b;
>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 78, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2b3 = b / c;
>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 79, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2b4 = b / d;
>r2b4 : Symbol(r2b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 80, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2b5 = b / e;
>r2b5 : Symbol(r2b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 81, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2b6 = b / f;
>r2b6 : Symbol(r2b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 82, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2c1 = c / a; //ok
>r2c1 : Symbol(r2c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 84, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2c2 = c / b;
>r2c2 : Symbol(r2c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 85, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2c3 = c / c; //ok
>r2c3 : Symbol(r2c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 86, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2c4 = c / d;
>r2c4 : Symbol(r2c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 87, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2c5 = c / e;
>r2c5 : Symbol(r2c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 88, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2c6 = c / f;
>r2c6 : Symbol(r2c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 89, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2d1 = d / a;
>r2d1 : Symbol(r2d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 91, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2d2 = d / b;
>r2d2 : Symbol(r2d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 92, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2d3 = d / c;
>r2d3 : Symbol(r2d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 93, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2d4 = d / d;
>r2d4 : Symbol(r2d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 94, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2d5 = d / e;
>r2d5 : Symbol(r2d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 95, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2d6 = d / f;
>r2d6 : Symbol(r2d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 96, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2e1 = e / a;
>r2e1 : Symbol(r2e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 98, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2e2 = e / b;
>r2e2 : Symbol(r2e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 99, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2e3 = e / c;
>r2e3 : Symbol(r2e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 100, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2e4 = e / d;
>r2e4 : Symbol(r2e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 101, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2e5 = e / e;
>r2e5 : Symbol(r2e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 102, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2e6 = e / f;
>r2e6 : Symbol(r2e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 103, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2f1 = f / a;
>r2f1 : Symbol(r2f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 105, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2f2 = f / b;
>r2f2 : Symbol(r2f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 106, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2f3 = f / c;
>r2f3 : Symbol(r2f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 107, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2f4 = f / d;
>r2f4 : Symbol(r2f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 108, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2f5 = f / e;
>r2f5 : Symbol(r2f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 109, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2f6 = f / f;
>r2f6 : Symbol(r2f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 110, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2g1 = E.a / a; //ok
>r2g1 : Symbol(r2g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 112, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r2g2 = E.a / b;
>r2g2 : Symbol(r2g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 113, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r2g3 = E.a / c; //ok
>r2g3 : Symbol(r2g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 114, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r2g4 = E.a / d;
>r2g4 : Symbol(r2g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 115, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r2g5 = E.a / e;
>r2g5 : Symbol(r2g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 116, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r2g6 = E.a / f;
>r2g6 : Symbol(r2g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 117, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r2h1 = a / E.b; //ok
>r2h1 : Symbol(r2h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 119, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r2h2 = b / E.b;
>r2h2 : Symbol(r2h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 120, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r2h3 = c / E.b; //ok
>r2h3 : Symbol(r2h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 121, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r2h4 = d / E.b;
>r2h4 : Symbol(r2h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 122, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r2h5 = e / E.b;
>r2h5 : Symbol(r2h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 123, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r2h6 = f / E.b;
>r2h6 : Symbol(r2h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 124, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -563,264 +563,264 @@ var r2h6 = f / E.b;
// operator %
var r3a1 = a % a; //ok
>r3a1 : Symbol(r3a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 127, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3a2 = a % b;
>r3a2 : Symbol(r3a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 128, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3a3 = a % c; //ok
>r3a3 : Symbol(r3a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 129, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3a4 = a % d;
>r3a4 : Symbol(r3a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 130, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3a5 = a % e;
>r3a5 : Symbol(r3a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 131, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3a6 = a % f;
>r3a6 : Symbol(r3a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 132, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3b1 = b % a;
>r3b1 : Symbol(r3b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 134, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3b2 = b % b;
>r3b2 : Symbol(r3b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 135, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3b3 = b % c;
>r3b3 : Symbol(r3b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 136, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3b4 = b % d;
>r3b4 : Symbol(r3b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 137, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3b5 = b % e;
>r3b5 : Symbol(r3b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 138, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3b6 = b % f;
>r3b6 : Symbol(r3b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 139, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3c1 = c % a; //ok
>r3c1 : Symbol(r3c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 141, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3c2 = c % b;
>r3c2 : Symbol(r3c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 142, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3c3 = c % c; //ok
>r3c3 : Symbol(r3c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 143, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3c4 = c % d;
>r3c4 : Symbol(r3c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 144, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3c5 = c % e;
>r3c5 : Symbol(r3c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 145, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3c6 = c % f;
>r3c6 : Symbol(r3c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 146, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3d1 = d % a;
>r3d1 : Symbol(r3d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 148, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3d2 = d % b;
>r3d2 : Symbol(r3d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 149, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3d3 = d % c;
>r3d3 : Symbol(r3d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 150, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3d4 = d % d;
>r3d4 : Symbol(r3d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 151, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3d5 = d % e;
>r3d5 : Symbol(r3d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 152, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3d6 = d % f;
>r3d6 : Symbol(r3d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 153, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3e1 = e % a;
>r3e1 : Symbol(r3e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 155, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3e2 = e % b;
>r3e2 : Symbol(r3e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 156, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3e3 = e % c;
>r3e3 : Symbol(r3e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 157, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3e4 = e % d;
>r3e4 : Symbol(r3e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 158, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3e5 = e % e;
>r3e5 : Symbol(r3e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 159, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3e6 = e % f;
>r3e6 : Symbol(r3e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 160, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3f1 = f % a;
>r3f1 : Symbol(r3f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 162, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3f2 = f % b;
>r3f2 : Symbol(r3f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 163, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3f3 = f % c;
>r3f3 : Symbol(r3f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 164, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3f4 = f % d;
>r3f4 : Symbol(r3f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 165, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3f5 = f % e;
>r3f5 : Symbol(r3f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 166, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3f6 = f % f;
>r3f6 : Symbol(r3f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 167, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3g1 = E.a % a; //ok
>r3g1 : Symbol(r3g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 169, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r3g2 = E.a % b;
>r3g2 : Symbol(r3g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 170, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r3g3 = E.a % c; //ok
>r3g3 : Symbol(r3g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 171, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r3g4 = E.a % d;
>r3g4 : Symbol(r3g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 172, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r3g5 = E.a % e;
>r3g5 : Symbol(r3g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 173, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r3g6 = E.a % f;
>r3g6 : Symbol(r3g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 174, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r3h1 = a % E.b; //ok
>r3h1 : Symbol(r3h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 176, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r3h2 = b % E.b;
>r3h2 : Symbol(r3h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 177, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r3h3 = c % E.b; //ok
>r3h3 : Symbol(r3h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 178, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r3h4 = d % E.b;
>r3h4 : Symbol(r3h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 179, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r3h5 = e % E.b;
>r3h5 : Symbol(r3h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 180, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r3h6 = f % E.b;
>r3h6 : Symbol(r3h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 181, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -828,264 +828,264 @@ var r3h6 = f % E.b;
// operator -
var r4a1 = a - a; //ok
>r4a1 : Symbol(r4a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 184, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4a2 = a - b;
>r4a2 : Symbol(r4a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 185, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4a3 = a - c; //ok
>r4a3 : Symbol(r4a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 186, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4a4 = a - d;
>r4a4 : Symbol(r4a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 187, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4a5 = a - e;
>r4a5 : Symbol(r4a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 188, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4a6 = a - f;
>r4a6 : Symbol(r4a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 189, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4b1 = b - a;
>r4b1 : Symbol(r4b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 191, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4b2 = b - b;
>r4b2 : Symbol(r4b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 192, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4b3 = b - c;
>r4b3 : Symbol(r4b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 193, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4b4 = b - d;
>r4b4 : Symbol(r4b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 194, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4b5 = b - e;
>r4b5 : Symbol(r4b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 195, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4b6 = b - f;
>r4b6 : Symbol(r4b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 196, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4c1 = c - a; //ok
>r4c1 : Symbol(r4c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 198, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4c2 = c - b;
>r4c2 : Symbol(r4c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 199, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4c3 = c - c; //ok
>r4c3 : Symbol(r4c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 200, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4c4 = c - d;
>r4c4 : Symbol(r4c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 201, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4c5 = c - e;
>r4c5 : Symbol(r4c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 202, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4c6 = c - f;
>r4c6 : Symbol(r4c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 203, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4d1 = d - a;
>r4d1 : Symbol(r4d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 205, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4d2 = d - b;
>r4d2 : Symbol(r4d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 206, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4d3 = d - c;
>r4d3 : Symbol(r4d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 207, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4d4 = d - d;
>r4d4 : Symbol(r4d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 208, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4d5 = d - e;
>r4d5 : Symbol(r4d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 209, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4d6 = d - f;
>r4d6 : Symbol(r4d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 210, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4e1 = e - a;
>r4e1 : Symbol(r4e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 212, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4e2 = e - b;
>r4e2 : Symbol(r4e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 213, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4e3 = e - c;
>r4e3 : Symbol(r4e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 214, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4e4 = e - d;
>r4e4 : Symbol(r4e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 215, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4e5 = e - e;
>r4e5 : Symbol(r4e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 216, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4e6 = e - f;
>r4e6 : Symbol(r4e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 217, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4f1 = f - a;
>r4f1 : Symbol(r4f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 219, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4f2 = f - b;
>r4f2 : Symbol(r4f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 220, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4f3 = f - c;
>r4f3 : Symbol(r4f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 221, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4f4 = f - d;
>r4f4 : Symbol(r4f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 222, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4f5 = f - e;
>r4f5 : Symbol(r4f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 223, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4f6 = f - f;
>r4f6 : Symbol(r4f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 224, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4g1 = E.a - a; //ok
>r4g1 : Symbol(r4g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 226, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r4g2 = E.a - b;
>r4g2 : Symbol(r4g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 227, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r4g3 = E.a - c; //ok
>r4g3 : Symbol(r4g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 228, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r4g4 = E.a - d;
>r4g4 : Symbol(r4g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 229, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r4g5 = E.a - e;
>r4g5 : Symbol(r4g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 230, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r4g6 = E.a - f;
>r4g6 : Symbol(r4g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 231, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r4h1 = a - E.b; //ok
>r4h1 : Symbol(r4h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 233, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r4h2 = b - E.b;
>r4h2 : Symbol(r4h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 234, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r4h3 = c - E.b; //ok
>r4h3 : Symbol(r4h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 235, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r4h4 = d - E.b;
>r4h4 : Symbol(r4h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 236, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r4h5 = e - E.b;
>r4h5 : Symbol(r4h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 237, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r4h6 = f - E.b;
>r4h6 : Symbol(r4h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 238, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -1093,264 +1093,264 @@ var r4h6 = f - E.b;
// operator <<
var r5a1 = a << a; //ok
>r5a1 : Symbol(r5a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 241, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5a2 = a << b;
>r5a2 : Symbol(r5a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 242, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5a3 = a << c; //ok
>r5a3 : Symbol(r5a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 243, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5a4 = a << d;
>r5a4 : Symbol(r5a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 244, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5a5 = a << e;
>r5a5 : Symbol(r5a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 245, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5a6 = a << f;
>r5a6 : Symbol(r5a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 246, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5b1 = b << a;
>r5b1 : Symbol(r5b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 248, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5b2 = b << b;
>r5b2 : Symbol(r5b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 249, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5b3 = b << c;
>r5b3 : Symbol(r5b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 250, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5b4 = b << d;
>r5b4 : Symbol(r5b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 251, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5b5 = b << e;
>r5b5 : Symbol(r5b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 252, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5b6 = b << f;
>r5b6 : Symbol(r5b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 253, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5c1 = c << a; //ok
>r5c1 : Symbol(r5c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 255, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5c2 = c << b;
>r5c2 : Symbol(r5c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 256, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5c3 = c << c; //ok
>r5c3 : Symbol(r5c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 257, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5c4 = c << d;
>r5c4 : Symbol(r5c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 258, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5c5 = c << e;
>r5c5 : Symbol(r5c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 259, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5c6 = c << f;
>r5c6 : Symbol(r5c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 260, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5d1 = d << a;
>r5d1 : Symbol(r5d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 262, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5d2 = d << b;
>r5d2 : Symbol(r5d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 263, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5d3 = d << c;
>r5d3 : Symbol(r5d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 264, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5d4 = d << d;
>r5d4 : Symbol(r5d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 265, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5d5 = d << e;
>r5d5 : Symbol(r5d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 266, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5d6 = d << f;
>r5d6 : Symbol(r5d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 267, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5e1 = e << a;
>r5e1 : Symbol(r5e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 269, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5e2 = e << b;
>r5e2 : Symbol(r5e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 270, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5e3 = e << c;
>r5e3 : Symbol(r5e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 271, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5e4 = e << d;
>r5e4 : Symbol(r5e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 272, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5e5 = e << e;
>r5e5 : Symbol(r5e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 273, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5e6 = e << f;
>r5e6 : Symbol(r5e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 274, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5f1 = f << a;
>r5f1 : Symbol(r5f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 276, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5f2 = f << b;
>r5f2 : Symbol(r5f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 277, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5f3 = f << c;
>r5f3 : Symbol(r5f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 278, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5f4 = f << d;
>r5f4 : Symbol(r5f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 279, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5f5 = f << e;
>r5f5 : Symbol(r5f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 280, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5f6 = f << f;
>r5f6 : Symbol(r5f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 281, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5g1 = E.a << a; //ok
>r5g1 : Symbol(r5g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 283, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r5g2 = E.a << b;
>r5g2 : Symbol(r5g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 284, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r5g3 = E.a << c; //ok
>r5g3 : Symbol(r5g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 285, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r5g4 = E.a << d;
>r5g4 : Symbol(r5g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 286, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r5g5 = E.a << e;
>r5g5 : Symbol(r5g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 287, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r5g6 = E.a << f;
>r5g6 : Symbol(r5g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 288, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r5h1 = a << E.b; //ok
>r5h1 : Symbol(r5h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 290, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r5h2 = b << E.b;
>r5h2 : Symbol(r5h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 291, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r5h3 = c << E.b; //ok
>r5h3 : Symbol(r5h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 292, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r5h4 = d << E.b;
>r5h4 : Symbol(r5h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 293, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r5h5 = e << E.b;
>r5h5 : Symbol(r5h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 294, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r5h6 = f << E.b;
>r5h6 : Symbol(r5h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 295, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -1358,264 +1358,264 @@ var r5h6 = f << E.b;
// operator >>
var r6a1 = a >> a; //ok
>r6a1 : Symbol(r6a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 298, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6a2 = a >> b;
>r6a2 : Symbol(r6a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 299, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6a3 = a >> c; //ok
>r6a3 : Symbol(r6a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 300, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6a4 = a >> d;
>r6a4 : Symbol(r6a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 301, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6a5 = a >> e;
>r6a5 : Symbol(r6a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 302, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6a6 = a >> f;
>r6a6 : Symbol(r6a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 303, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6b1 = b >> a;
>r6b1 : Symbol(r6b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 305, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6b2 = b >> b;
>r6b2 : Symbol(r6b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 306, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6b3 = b >> c;
>r6b3 : Symbol(r6b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 307, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6b4 = b >> d;
>r6b4 : Symbol(r6b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 308, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6b5 = b >> e;
>r6b5 : Symbol(r6b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 309, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6b6 = b >> f;
>r6b6 : Symbol(r6b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 310, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6c1 = c >> a; //ok
>r6c1 : Symbol(r6c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 312, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6c2 = c >> b;
>r6c2 : Symbol(r6c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 313, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6c3 = c >> c; //ok
>r6c3 : Symbol(r6c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 314, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6c4 = c >> d;
>r6c4 : Symbol(r6c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 315, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6c5 = c >> e;
>r6c5 : Symbol(r6c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 316, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6c6 = c >> f;
>r6c6 : Symbol(r6c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 317, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6d1 = d >> a;
>r6d1 : Symbol(r6d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 319, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6d2 = d >> b;
>r6d2 : Symbol(r6d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 320, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6d3 = d >> c;
>r6d3 : Symbol(r6d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 321, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6d4 = d >> d;
>r6d4 : Symbol(r6d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 322, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6d5 = d >> e;
>r6d5 : Symbol(r6d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 323, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6d6 = d >> f;
>r6d6 : Symbol(r6d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 324, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6e1 = e >> a;
>r6e1 : Symbol(r6e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 326, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6e2 = e >> b;
>r6e2 : Symbol(r6e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 327, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6e3 = e >> c;
>r6e3 : Symbol(r6e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 328, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6e4 = e >> d;
>r6e4 : Symbol(r6e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 329, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6e5 = e >> e;
>r6e5 : Symbol(r6e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 330, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6e6 = e >> f;
>r6e6 : Symbol(r6e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 331, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6f1 = f >> a;
>r6f1 : Symbol(r6f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 333, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6f2 = f >> b;
>r6f2 : Symbol(r6f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 334, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6f3 = f >> c;
>r6f3 : Symbol(r6f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 335, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6f4 = f >> d;
>r6f4 : Symbol(r6f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 336, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6f5 = f >> e;
>r6f5 : Symbol(r6f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 337, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6f6 = f >> f;
>r6f6 : Symbol(r6f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 338, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6g1 = E.a >> a; //ok
>r6g1 : Symbol(r6g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 340, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r6g2 = E.a >> b;
>r6g2 : Symbol(r6g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 341, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r6g3 = E.a >> c; //ok
>r6g3 : Symbol(r6g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 342, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r6g4 = E.a >> d;
>r6g4 : Symbol(r6g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 343, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r6g5 = E.a >> e;
>r6g5 : Symbol(r6g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 344, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r6g6 = E.a >> f;
>r6g6 : Symbol(r6g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 345, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r6h1 = a >> E.b; //ok
>r6h1 : Symbol(r6h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 347, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r6h2 = b >> E.b;
>r6h2 : Symbol(r6h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 348, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r6h3 = c >> E.b; //ok
>r6h3 : Symbol(r6h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 349, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r6h4 = d >> E.b;
>r6h4 : Symbol(r6h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 350, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r6h5 = e >> E.b;
>r6h5 : Symbol(r6h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 351, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r6h6 = f >> E.b;
>r6h6 : Symbol(r6h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 352, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -1623,264 +1623,264 @@ var r6h6 = f >> E.b;
// operator >>>
var r7a1 = a >>> a; //ok
>r7a1 : Symbol(r7a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 355, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7a2 = a >>> b;
>r7a2 : Symbol(r7a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 356, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7a3 = a >>> c; //ok
>r7a3 : Symbol(r7a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 357, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7a4 = a >>> d;
>r7a4 : Symbol(r7a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 358, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7a5 = a >>> e;
>r7a5 : Symbol(r7a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 359, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7a6 = a >>> f;
>r7a6 : Symbol(r7a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 360, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7b1 = b >>> a;
>r7b1 : Symbol(r7b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 362, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7b2 = b >>> b;
>r7b2 : Symbol(r7b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 363, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7b3 = b >>> c;
>r7b3 : Symbol(r7b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 364, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7b4 = b >>> d;
>r7b4 : Symbol(r7b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 365, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7b5 = b >>> e;
>r7b5 : Symbol(r7b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 366, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7b6 = b >>> f;
>r7b6 : Symbol(r7b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 367, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7c1 = c >>> a; //ok
>r7c1 : Symbol(r7c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 369, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7c2 = c >>> b;
>r7c2 : Symbol(r7c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 370, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7c3 = c >>> c; //ok
>r7c3 : Symbol(r7c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 371, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7c4 = c >>> d;
>r7c4 : Symbol(r7c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 372, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7c5 = c >>> e;
>r7c5 : Symbol(r7c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 373, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7c6 = c >>> f;
>r7c6 : Symbol(r7c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 374, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7d1 = d >>> a;
>r7d1 : Symbol(r7d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 376, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7d2 = d >>> b;
>r7d2 : Symbol(r7d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 377, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7d3 = d >>> c;
>r7d3 : Symbol(r7d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 378, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7d4 = d >>> d;
>r7d4 : Symbol(r7d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 379, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7d5 = d >>> e;
>r7d5 : Symbol(r7d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 380, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7d6 = d >>> f;
>r7d6 : Symbol(r7d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 381, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7e1 = e >>> a;
>r7e1 : Symbol(r7e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 383, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7e2 = e >>> b;
>r7e2 : Symbol(r7e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 384, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7e3 = e >>> c;
>r7e3 : Symbol(r7e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 385, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7e4 = e >>> d;
>r7e4 : Symbol(r7e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 386, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7e5 = e >>> e;
>r7e5 : Symbol(r7e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 387, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7e6 = e >>> f;
>r7e6 : Symbol(r7e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 388, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7f1 = f >>> a;
>r7f1 : Symbol(r7f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 390, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7f2 = f >>> b;
>r7f2 : Symbol(r7f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 391, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7f3 = f >>> c;
>r7f3 : Symbol(r7f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 392, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7f4 = f >>> d;
>r7f4 : Symbol(r7f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 393, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7f5 = f >>> e;
>r7f5 : Symbol(r7f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 394, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7f6 = f >>> f;
>r7f6 : Symbol(r7f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 395, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7g1 = E.a >>> a; //ok
>r7g1 : Symbol(r7g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 397, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r7g2 = E.a >>> b;
>r7g2 : Symbol(r7g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 398, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r7g3 = E.a >>> c; //ok
>r7g3 : Symbol(r7g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 399, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r7g4 = E.a >>> d;
>r7g4 : Symbol(r7g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 400, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r7g5 = E.a >>> e;
>r7g5 : Symbol(r7g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 401, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r7g6 = E.a >>> f;
>r7g6 : Symbol(r7g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 402, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r7h1 = a >>> E.b; //ok
>r7h1 : Symbol(r7h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 404, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r7h2 = b >>> E.b;
>r7h2 : Symbol(r7h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 405, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r7h3 = c >>> E.b; //ok
>r7h3 : Symbol(r7h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 406, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r7h4 = d >>> E.b;
>r7h4 : Symbol(r7h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 407, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r7h5 = e >>> E.b;
>r7h5 : Symbol(r7h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 408, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r7h6 = f >>> E.b;
>r7h6 : Symbol(r7h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 409, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -1888,264 +1888,264 @@ var r7h6 = f >>> E.b;
// operator &
var r8a1 = a & a; //ok
>r8a1 : Symbol(r8a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 412, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8a2 = a & b;
>r8a2 : Symbol(r8a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 413, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8a3 = a & c; //ok
>r8a3 : Symbol(r8a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 414, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8a4 = a & d;
>r8a4 : Symbol(r8a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 415, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8a5 = a & e;
>r8a5 : Symbol(r8a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 416, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8a6 = a & f;
>r8a6 : Symbol(r8a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 417, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8b1 = b & a;
>r8b1 : Symbol(r8b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 419, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8b2 = b & b;
>r8b2 : Symbol(r8b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 420, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8b3 = b & c;
>r8b3 : Symbol(r8b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 421, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8b4 = b & d;
>r8b4 : Symbol(r8b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 422, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8b5 = b & e;
>r8b5 : Symbol(r8b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 423, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8b6 = b & f;
>r8b6 : Symbol(r8b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 424, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8c1 = c & a; //ok
>r8c1 : Symbol(r8c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 426, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8c2 = c & b;
>r8c2 : Symbol(r8c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 427, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8c3 = c & c; //ok
>r8c3 : Symbol(r8c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 428, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8c4 = c & d;
>r8c4 : Symbol(r8c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 429, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8c5 = c & e;
>r8c5 : Symbol(r8c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 430, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8c6 = c & f;
>r8c6 : Symbol(r8c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 431, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8d1 = d & a;
>r8d1 : Symbol(r8d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 433, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8d2 = d & b;
>r8d2 : Symbol(r8d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 434, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8d3 = d & c;
>r8d3 : Symbol(r8d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 435, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8d4 = d & d;
>r8d4 : Symbol(r8d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 436, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8d5 = d & e;
>r8d5 : Symbol(r8d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 437, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8d6 = d & f;
>r8d6 : Symbol(r8d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 438, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8e1 = e & a;
>r8e1 : Symbol(r8e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 440, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8e2 = e & b;
>r8e2 : Symbol(r8e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 441, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8e3 = e & c;
>r8e3 : Symbol(r8e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 442, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8e4 = e & d;
>r8e4 : Symbol(r8e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 443, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8e5 = e & e;
>r8e5 : Symbol(r8e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 444, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8e6 = e & f;
>r8e6 : Symbol(r8e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 445, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8f1 = f & a;
>r8f1 : Symbol(r8f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 447, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8f2 = f & b;
>r8f2 : Symbol(r8f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 448, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8f3 = f & c;
>r8f3 : Symbol(r8f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 449, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8f4 = f & d;
>r8f4 : Symbol(r8f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 450, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8f5 = f & e;
>r8f5 : Symbol(r8f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 451, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8f6 = f & f;
>r8f6 : Symbol(r8f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 452, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8g1 = E.a & a; //ok
>r8g1 : Symbol(r8g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 454, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r8g2 = E.a & b;
>r8g2 : Symbol(r8g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 455, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r8g3 = E.a & c; //ok
>r8g3 : Symbol(r8g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 456, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r8g4 = E.a & d;
>r8g4 : Symbol(r8g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 457, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r8g5 = E.a & e;
>r8g5 : Symbol(r8g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 458, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r8g6 = E.a & f;
>r8g6 : Symbol(r8g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 459, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r8h1 = a & E.b; //ok
>r8h1 : Symbol(r8h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 461, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r8h2 = b & E.b;
>r8h2 : Symbol(r8h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 462, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r8h3 = c & E.b; //ok
>r8h3 : Symbol(r8h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 463, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r8h4 = d & E.b;
>r8h4 : Symbol(r8h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 464, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r8h5 = e & E.b;
>r8h5 : Symbol(r8h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 465, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r8h6 = f & E.b;
>r8h6 : Symbol(r8h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 466, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -2153,264 +2153,264 @@ var r8h6 = f & E.b;
// operator ^
var r9a1 = a ^ a; //ok
>r9a1 : Symbol(r9a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 469, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9a2 = a ^ b;
>r9a2 : Symbol(r9a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 470, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9a3 = a ^ c; //ok
>r9a3 : Symbol(r9a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 471, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9a4 = a ^ d;
>r9a4 : Symbol(r9a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 472, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9a5 = a ^ e;
>r9a5 : Symbol(r9a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 473, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9a6 = a ^ f;
>r9a6 : Symbol(r9a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 474, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9b1 = b ^ a;
>r9b1 : Symbol(r9b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 476, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9b2 = b ^ b;
>r9b2 : Symbol(r9b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 477, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9b3 = b ^ c;
>r9b3 : Symbol(r9b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 478, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9b4 = b ^ d;
>r9b4 : Symbol(r9b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 479, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9b5 = b ^ e;
>r9b5 : Symbol(r9b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 480, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9b6 = b ^ f;
>r9b6 : Symbol(r9b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 481, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9c1 = c ^ a; //ok
>r9c1 : Symbol(r9c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 483, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9c2 = c ^ b;
>r9c2 : Symbol(r9c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 484, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9c3 = c ^ c; //ok
>r9c3 : Symbol(r9c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 485, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9c4 = c ^ d;
>r9c4 : Symbol(r9c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 486, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9c5 = c ^ e;
>r9c5 : Symbol(r9c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 487, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9c6 = c ^ f;
>r9c6 : Symbol(r9c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 488, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9d1 = d ^ a;
>r9d1 : Symbol(r9d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 490, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9d2 = d ^ b;
>r9d2 : Symbol(r9d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 491, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9d3 = d ^ c;
>r9d3 : Symbol(r9d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 492, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9d4 = d ^ d;
>r9d4 : Symbol(r9d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 493, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9d5 = d ^ e;
>r9d5 : Symbol(r9d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 494, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9d6 = d ^ f;
>r9d6 : Symbol(r9d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 495, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9e1 = e ^ a;
>r9e1 : Symbol(r9e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 497, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9e2 = e ^ b;
>r9e2 : Symbol(r9e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 498, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9e3 = e ^ c;
>r9e3 : Symbol(r9e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 499, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9e4 = e ^ d;
>r9e4 : Symbol(r9e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 500, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9e5 = e ^ e;
>r9e5 : Symbol(r9e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 501, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9e6 = e ^ f;
>r9e6 : Symbol(r9e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 502, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9f1 = f ^ a;
>r9f1 : Symbol(r9f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 504, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9f2 = f ^ b;
>r9f2 : Symbol(r9f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 505, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9f3 = f ^ c;
>r9f3 : Symbol(r9f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 506, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9f4 = f ^ d;
>r9f4 : Symbol(r9f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 507, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9f5 = f ^ e;
>r9f5 : Symbol(r9f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 508, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9f6 = f ^ f;
>r9f6 : Symbol(r9f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 509, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9g1 = E.a ^ a; //ok
>r9g1 : Symbol(r9g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 511, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r9g2 = E.a ^ b;
>r9g2 : Symbol(r9g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 512, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r9g3 = E.a ^ c; //ok
>r9g3 : Symbol(r9g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 513, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r9g4 = E.a ^ d;
>r9g4 : Symbol(r9g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 514, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r9g5 = E.a ^ e;
>r9g5 : Symbol(r9g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 515, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r9g6 = E.a ^ f;
>r9g6 : Symbol(r9g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 516, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r9h1 = a ^ E.b; //ok
>r9h1 : Symbol(r9h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 518, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r9h2 = b ^ E.b;
>r9h2 : Symbol(r9h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 519, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r9h3 = c ^ E.b; //ok
>r9h3 : Symbol(r9h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 520, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r9h4 = d ^ E.b;
>r9h4 : Symbol(r9h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 521, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r9h5 = e ^ E.b;
>r9h5 : Symbol(r9h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 522, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r9h6 = f ^ E.b;
>r9h6 : Symbol(r9h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 523, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
@@ -2418,264 +2418,264 @@ var r9h6 = f ^ E.b;
// operator |
var r10a1 = a | a; //ok
>r10a1 : Symbol(r10a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 526, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10a2 = a | b;
>r10a2 : Symbol(r10a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 527, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10a3 = a | c; //ok
>r10a3 : Symbol(r10a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 528, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10a4 = a | d;
>r10a4 : Symbol(r10a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 529, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10a5 = a | e;
>r10a5 : Symbol(r10a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 530, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10a6 = a | f;
>r10a6 : Symbol(r10a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 531, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10b1 = b | a;
>r10b1 : Symbol(r10b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 533, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10b2 = b | b;
>r10b2 : Symbol(r10b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 534, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10b3 = b | c;
>r10b3 : Symbol(r10b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 535, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10b4 = b | d;
>r10b4 : Symbol(r10b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 536, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10b5 = b | e;
>r10b5 : Symbol(r10b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 537, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10b6 = b | f;
>r10b6 : Symbol(r10b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 538, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10c1 = c | a; //ok
>r10c1 : Symbol(r10c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 540, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10c2 = c | b;
>r10c2 : Symbol(r10c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 541, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10c3 = c | c; //ok
>r10c3 : Symbol(r10c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 542, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10c4 = c | d;
>r10c4 : Symbol(r10c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 543, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10c5 = c | e;
>r10c5 : Symbol(r10c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 544, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10c6 = c | f;
>r10c6 : Symbol(r10c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 545, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10d1 = d | a;
>r10d1 : Symbol(r10d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 547, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10d2 = d | b;
>r10d2 : Symbol(r10d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 548, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10d3 = d | c;
>r10d3 : Symbol(r10d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 549, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10d4 = d | d;
>r10d4 : Symbol(r10d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 550, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10d5 = d | e;
>r10d5 : Symbol(r10d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 551, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10d6 = d | f;
>r10d6 : Symbol(r10d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 552, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10e1 = e | a;
>r10e1 : Symbol(r10e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 554, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10e2 = e | b;
>r10e2 : Symbol(r10e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 555, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10e3 = e | c;
>r10e3 : Symbol(r10e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 556, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10e4 = e | d;
>r10e4 : Symbol(r10e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 557, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10e5 = e | e;
>r10e5 : Symbol(r10e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 558, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10e6 = e | f;
>r10e6 : Symbol(r10e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 559, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10f1 = f | a;
>r10f1 : Symbol(r10f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 561, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10f2 = f | b;
>r10f2 : Symbol(r10f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 562, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10f3 = f | c;
>r10f3 : Symbol(r10f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 563, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10f4 = f | d;
>r10f4 : Symbol(r10f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 564, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10f5 = f | e;
>r10f5 : Symbol(r10f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 565, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10f6 = f | f;
>r10f6 : Symbol(r10f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 566, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10g1 = E.a | a; //ok
>r10g1 : Symbol(r10g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 568, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
var r10g2 = E.a | b;
>r10g2 : Symbol(r10g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 569, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
var r10g3 = E.a | c; //ok
>r10g3 : Symbol(r10g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 570, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
var r10g4 = E.a | d;
>r10g4 : Symbol(r10g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 571, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
var r10g5 = E.a | e;
>r10g5 : Symbol(r10g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 572, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
var r10g6 = E.a | f;
>r10g6 : Symbol(r10g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 573, 3))
>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
var r10h1 = a | E.b; //ok
>r10h1 : Symbol(r10h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 575, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r10h2 = b | E.b;
>r10h2 : Symbol(r10h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 576, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r10h3 = c | E.b; //ok
>r10h3 : Symbol(r10h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 577, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r10h4 = d | E.b;
>r10h4 : Symbol(r10h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 578, 3))
->d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3))
+>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r10h5 = e | E.b;
>r10h5 : Symbol(r10h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 579, 3))
->e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3))
+>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
var r10h6 = f | E.b;
>r10h6 : Symbol(r10h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 580, 3))
->f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3))
+>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 11))
>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0))
>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11))
diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types
index f891e3ee4fbc7..1cef952e10efa 100644
--- a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types
+++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types
@@ -13,29 +13,29 @@ enum E { a, b, c }
>c : E.c
> : ^^^
-var a: any;
+declare var a: any;
>a : any
> : ^^^
-var b: boolean;
+declare var b: boolean;
>b : boolean
> : ^^^^^^^
-var c: number;
+declare var c: number;
>c : number
> : ^^^^^^
-var d: string;
+declare var d: string;
>d : string
> : ^^^^^^
-var e: { a: number };
+declare var e: { a: number };
>e : { a: number; }
> : ^^^^^ ^^^
>a : number
> : ^^^^^^
-var f: Number;
+declare var f: Number;
>f : Number
> : ^^^^^^
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt
index 2d254bda40710..a71c0deaa7922 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt
@@ -244,9 +244,9 @@ arithmeticOperatorWithNullValueAndInvalidOperands.ts(176,18): error TS18050: The
// If one operand is the null or undefined value, it is treated as having the type of the
// other operand.
- var a: boolean;
- var b: string;
- var c: Object;
+ declare var a: boolean;
+ declare var b: string;
+ declare var c: Object;
// operator *
var r1a1 = null * a;
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.js b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.js
index 244abd14561e6..9cd24a96541d2 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.js
@@ -4,9 +4,9 @@
// If one operand is the null or undefined value, it is treated as having the type of the
// other operand.
-var a: boolean;
-var b: string;
-var c: Object;
+declare var a: boolean;
+declare var b: string;
+declare var c: Object;
// operator *
var r1a1 = null * a;
@@ -181,9 +181,6 @@ var r10d3 = {} | null;
//// [arithmeticOperatorWithNullValueAndInvalidOperands.js]
// If one operand is the null or undefined value, it is treated as having the type of the
// other operand.
-var a;
-var b;
-var c;
// operator *
var r1a1 = null * a;
var r1a2 = null * b;
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols
index 09060fcd5f1ca..d5ba2cf80d8c7 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols
@@ -4,40 +4,40 @@
// If one operand is the null or undefined value, it is treated as having the type of the
// other operand.
-var a: boolean;
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+declare var a: boolean;
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
-var b: string;
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+declare var b: string;
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
-var c: Object;
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+declare var c: Object;
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
// operator *
var r1a1 = null * a;
>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 8, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r1a2 = null * b;
>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 9, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r1a3 = null * c;
>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 10, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r1b1 = a * null;
>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 12, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r1b2 = b * null;
>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 13, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r1b3 = c * null;
>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 14, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r1c1 = null * true;
>r1c1 : Symbol(r1c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 16, 3))
@@ -60,27 +60,27 @@ var r1d3 = {} * null;
// operator /
var r2a1 = null / a;
>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 25, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r2a2 = null / b;
>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 26, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r2a3 = null / c;
>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 27, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r2b1 = a / null;
>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 29, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r2b2 = b / null;
>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 30, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r2b3 = c / null;
>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 31, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r2c1 = null / true;
>r2c1 : Symbol(r2c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 33, 3))
@@ -103,27 +103,27 @@ var r2d3 = {} / null;
// operator %
var r3a1 = null % a;
>r3a1 : Symbol(r3a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 42, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r3a2 = null % b;
>r3a2 : Symbol(r3a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 43, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r3a3 = null % c;
>r3a3 : Symbol(r3a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 44, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r3b1 = a % null;
>r3b1 : Symbol(r3b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 46, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r3b2 = b % null;
>r3b2 : Symbol(r3b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 47, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r3b3 = c % null;
>r3b3 : Symbol(r3b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 48, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r3c1 = null % true;
>r3c1 : Symbol(r3c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 50, 3))
@@ -146,27 +146,27 @@ var r3d3 = {} % null;
// operator -
var r4a1 = null - a;
>r4a1 : Symbol(r4a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 59, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r4a2 = null - b;
>r4a2 : Symbol(r4a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 60, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r4a3 = null - c;
>r4a3 : Symbol(r4a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 61, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r4b1 = a - null;
>r4b1 : Symbol(r4b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 63, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r4b2 = b - null;
>r4b2 : Symbol(r4b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 64, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r4b3 = c - null;
>r4b3 : Symbol(r4b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 65, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r4c1 = null - true;
>r4c1 : Symbol(r4c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 67, 3))
@@ -189,27 +189,27 @@ var r4d3 = {} - null;
// operator <<
var r5a1 = null << a;
>r5a1 : Symbol(r5a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 76, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r5a2 = null << b;
>r5a2 : Symbol(r5a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 77, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r5a3 = null << c;
>r5a3 : Symbol(r5a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 78, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r5b1 = a << null;
>r5b1 : Symbol(r5b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 80, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r5b2 = b << null;
>r5b2 : Symbol(r5b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 81, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r5b3 = c << null;
>r5b3 : Symbol(r5b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 82, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r5c1 = null << true;
>r5c1 : Symbol(r5c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 84, 3))
@@ -232,27 +232,27 @@ var r5d3 = {} << null;
// operator >>
var r6a1 = null >> a;
>r6a1 : Symbol(r6a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 93, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r6a2 = null >> b;
>r6a2 : Symbol(r6a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 94, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r6a3 = null >> c;
>r6a3 : Symbol(r6a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 95, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r6b1 = a >> null;
>r6b1 : Symbol(r6b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 97, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r6b2 = b >> null;
>r6b2 : Symbol(r6b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 98, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r6b3 = c >> null;
>r6b3 : Symbol(r6b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 99, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r6c1 = null >> true;
>r6c1 : Symbol(r6c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 101, 3))
@@ -275,27 +275,27 @@ var r6d3 = {} >> null;
// operator >>>
var r7a1 = null >>> a;
>r7a1 : Symbol(r7a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 110, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r7a2 = null >>> b;
>r7a2 : Symbol(r7a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 111, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r7a3 = null >>> c;
>r7a3 : Symbol(r7a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 112, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r7b1 = a >>> null;
>r7b1 : Symbol(r7b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 114, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r7b2 = b >>> null;
>r7b2 : Symbol(r7b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 115, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r7b3 = c >>> null;
>r7b3 : Symbol(r7b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 116, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r7c1 = null >>> true;
>r7c1 : Symbol(r7c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 118, 3))
@@ -318,27 +318,27 @@ var r7d3 = {} >>> null;
// operator &
var r8a1 = null & a;
>r8a1 : Symbol(r8a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 127, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r8a2 = null & b;
>r8a2 : Symbol(r8a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 128, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r8a3 = null & c;
>r8a3 : Symbol(r8a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 129, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r8b1 = a & null;
>r8b1 : Symbol(r8b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 131, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r8b2 = b & null;
>r8b2 : Symbol(r8b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 132, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r8b3 = c & null;
>r8b3 : Symbol(r8b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 133, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r8c1 = null & true;
>r8c1 : Symbol(r8c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 135, 3))
@@ -361,27 +361,27 @@ var r8d3 = {} & null;
// operator ^
var r9a1 = null ^ a;
>r9a1 : Symbol(r9a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 144, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r9a2 = null ^ b;
>r9a2 : Symbol(r9a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 145, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r9a3 = null ^ c;
>r9a3 : Symbol(r9a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 146, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r9b1 = a ^ null;
>r9b1 : Symbol(r9b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 148, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r9b2 = b ^ null;
>r9b2 : Symbol(r9b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 149, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r9b3 = c ^ null;
>r9b3 : Symbol(r9b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 150, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r9c1 = null ^ true;
>r9c1 : Symbol(r9c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 152, 3))
@@ -404,27 +404,27 @@ var r9d3 = {} ^ null;
// operator |
var r10a1 = null | a;
>r10a1 : Symbol(r10a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 161, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r10a2 = null | b;
>r10a2 : Symbol(r10a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 162, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r10a3 = null | c;
>r10a3 : Symbol(r10a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 163, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r10b1 = a | null;
>r10b1 : Symbol(r10b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 165, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 11))
var r10b2 = b | null;
>r10b2 : Symbol(r10b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 166, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 11))
var r10b3 = c | null;
>r10b3 : Symbol(r10b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 167, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 11))
var r10c1 = null | true;
>r10c1 : Symbol(r10c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 169, 3))
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types
index ba7ec86c6502b..8701591dc517b 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types
@@ -4,15 +4,15 @@
// If one operand is the null or undefined value, it is treated as having the type of the
// other operand.
-var a: boolean;
+declare var a: boolean;
>a : boolean
> : ^^^^^^^
-var b: string;
+declare var b: string;
>b : string
> : ^^^^^^
-var c: Object;
+declare var c: Object;
>c : Object
> : ^^^^^^
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt
index dbb3c8ee7036a..4a4e273a4ac82 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt
@@ -89,8 +89,8 @@ arithmeticOperatorWithNullValueAndValidOperands.ts(110,17): error TS18050: The v
b
}
- var a: any;
- var b: number;
+ declare var a: any;
+ declare var b: number;
// operator *
var ra1 = null * a;
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js
index fa3b897c3cc54..eef8b00890737 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js
@@ -9,8 +9,8 @@ enum E {
b
}
-var a: any;
-var b: number;
+declare var a: any;
+declare var b: number;
// operator *
var ra1 = null * a;
@@ -120,8 +120,6 @@ var E;
E[E["a"] = 0] = "a";
E[E["b"] = 1] = "b";
})(E || (E = {}));
-var a;
-var b;
// operator *
var ra1 = null * a;
var ra2 = null * b;
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.symbols
index 971e192d68aa7..16429a1b9a7a2 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.symbols
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.symbols
@@ -14,20 +14,20 @@ enum E {
>b : Symbol(E.b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 4, 6))
}
-var a: any;
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+declare var a: any;
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
-var b: number;
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+declare var b: number;
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
// operator *
var ra1 = null * a;
>ra1 : Symbol(ra1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 12, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var ra2 = null * b;
>ra2 : Symbol(ra2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 13, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var ra3 = null * 1;
>ra3 : Symbol(ra3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 14, 3))
@@ -40,11 +40,11 @@ var ra4 = null * E.a;
var ra5 = a * null;
>ra5 : Symbol(ra5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 16, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var ra6 = b * null;
>ra6 : Symbol(ra6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 17, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var ra7 = 0 * null;
>ra7 : Symbol(ra7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 18, 3))
@@ -58,11 +58,11 @@ var ra8 = E.b * null;
// operator /
var rb1 = null / a;
>rb1 : Symbol(rb1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 22, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rb2 = null / b;
>rb2 : Symbol(rb2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 23, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rb3 = null / 1;
>rb3 : Symbol(rb3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 24, 3))
@@ -75,11 +75,11 @@ var rb4 = null / E.a;
var rb5 = a / null;
>rb5 : Symbol(rb5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 26, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rb6 = b / null;
>rb6 : Symbol(rb6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 27, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rb7 = 0 / null;
>rb7 : Symbol(rb7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 28, 3))
@@ -93,11 +93,11 @@ var rb8 = E.b / null;
// operator %
var rc1 = null % a;
>rc1 : Symbol(rc1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 32, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rc2 = null % b;
>rc2 : Symbol(rc2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 33, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rc3 = null % 1;
>rc3 : Symbol(rc3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 34, 3))
@@ -110,11 +110,11 @@ var rc4 = null % E.a;
var rc5 = a % null;
>rc5 : Symbol(rc5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 36, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rc6 = b % null;
>rc6 : Symbol(rc6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 37, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rc7 = 0 % null;
>rc7 : Symbol(rc7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 38, 3))
@@ -128,11 +128,11 @@ var rc8 = E.b % null;
// operator -
var rd1 = null - a;
>rd1 : Symbol(rd1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 42, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rd2 = null - b;
>rd2 : Symbol(rd2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 43, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rd3 = null - 1;
>rd3 : Symbol(rd3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 44, 3))
@@ -145,11 +145,11 @@ var rd4 = null - E.a;
var rd5 = a - null;
>rd5 : Symbol(rd5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 46, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rd6 = b - null;
>rd6 : Symbol(rd6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 47, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rd7 = 0 - null;
>rd7 : Symbol(rd7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 48, 3))
@@ -163,11 +163,11 @@ var rd8 = E.b - null;
// operator <<
var re1 = null << a;
>re1 : Symbol(re1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 52, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var re2 = null << b;
>re2 : Symbol(re2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 53, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var re3 = null << 1;
>re3 : Symbol(re3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 54, 3))
@@ -180,11 +180,11 @@ var re4 = null << E.a;
var re5 = a << null;
>re5 : Symbol(re5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 56, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var re6 = b << null;
>re6 : Symbol(re6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 57, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var re7 = 0 << null;
>re7 : Symbol(re7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 58, 3))
@@ -198,11 +198,11 @@ var re8 = E.b << null;
// operator >>
var rf1 = null >> a;
>rf1 : Symbol(rf1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 62, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rf2 = null >> b;
>rf2 : Symbol(rf2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 63, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rf3 = null >> 1;
>rf3 : Symbol(rf3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 64, 3))
@@ -215,11 +215,11 @@ var rf4 = null >> E.a;
var rf5 = a >> null;
>rf5 : Symbol(rf5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 66, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rf6 = b >> null;
>rf6 : Symbol(rf6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 67, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rf7 = 0 >> null;
>rf7 : Symbol(rf7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 68, 3))
@@ -233,11 +233,11 @@ var rf8 = E.b >> null;
// operator >>>
var rg1 = null >>> a;
>rg1 : Symbol(rg1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 72, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rg2 = null >>> b;
>rg2 : Symbol(rg2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 73, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rg3 = null >>> 1;
>rg3 : Symbol(rg3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 74, 3))
@@ -250,11 +250,11 @@ var rg4 = null >>> E.a;
var rg5 = a >>> null;
>rg5 : Symbol(rg5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 76, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rg6 = b >>> null;
>rg6 : Symbol(rg6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 77, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rg7 = 0 >>> null;
>rg7 : Symbol(rg7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 78, 3))
@@ -268,11 +268,11 @@ var rg8 = E.b >>> null;
// operator &
var rh1 = null & a;
>rh1 : Symbol(rh1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 82, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rh2 = null & b;
>rh2 : Symbol(rh2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 83, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rh3 = null & 1;
>rh3 : Symbol(rh3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 84, 3))
@@ -285,11 +285,11 @@ var rh4 = null & E.a;
var rh5 = a & null;
>rh5 : Symbol(rh5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 86, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rh6 = b & null;
>rh6 : Symbol(rh6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 87, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rh7 = 0 & null;
>rh7 : Symbol(rh7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 88, 3))
@@ -303,11 +303,11 @@ var rh8 = E.b & null;
// operator ^
var ri1 = null ^ a;
>ri1 : Symbol(ri1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 92, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var ri2 = null ^ b;
>ri2 : Symbol(ri2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 93, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var ri3 = null ^ 1;
>ri3 : Symbol(ri3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 94, 3))
@@ -320,11 +320,11 @@ var ri4 = null ^ E.a;
var ri5 = a ^ null;
>ri5 : Symbol(ri5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 96, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var ri6 = b ^ null;
>ri6 : Symbol(ri6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 97, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var ri7 = 0 ^ null;
>ri7 : Symbol(ri7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 98, 3))
@@ -338,11 +338,11 @@ var ri8 = E.b ^ null;
// operator |
var rj1 = null | a;
>rj1 : Symbol(rj1, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 102, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rj2 = null | b;
>rj2 : Symbol(rj2, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 103, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rj3 = null | 1;
>rj3 : Symbol(rj3, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 104, 3))
@@ -355,11 +355,11 @@ var rj4 = null | E.a;
var rj5 = a | null;
>rj5 : Symbol(rj5, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 106, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 8, 11))
var rj6 = b | null;
>rj6 : Symbol(rj6, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 107, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 9, 11))
var rj7 = 0 | null;
>rj7 : Symbol(rj7, Decl(arithmeticOperatorWithNullValueAndValidOperands.ts, 108, 3))
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.types b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.types
index 98cc230a9471c..028613f87ccdc 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.types
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.types
@@ -17,11 +17,11 @@ enum E {
> : ^^^
}
-var a: any;
+declare var a: any;
>a : any
> : ^^^
-var b: number;
+declare var b: number;
>b : number
> : ^^^^^^
diff --git a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.errors.txt b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.errors.txt
index 8d895278b97f7..f64a079e3ca9b 100644
--- a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.errors.txt
@@ -183,11 +183,11 @@ arithmeticOperatorWithTypeParameter.ts(128,21): error TS2363: The right-hand sid
==== arithmeticOperatorWithTypeParameter.ts (180 errors) ====
// type parameter type is not valid for arithmetic operand
function foo(t: T) {
- var a: any;
- var b: boolean;
- var c: number;
- var d: string;
- var e: {};
+ let a!: any;
+ let b!: boolean;
+ let c!: number;
+ let d!: string;
+ let e!: {};
var r1a1 = a * t;
~
diff --git a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.js b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.js
index 6c76194913b6e..b25225c6e579a 100644
--- a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.js
+++ b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.js
@@ -3,11 +3,11 @@
//// [arithmeticOperatorWithTypeParameter.ts]
// type parameter type is not valid for arithmetic operand
function foo(t: T) {
- var a: any;
- var b: boolean;
- var c: number;
- var d: string;
- var e: {};
+ let a!: any;
+ let b!: boolean;
+ let c!: number;
+ let d!: string;
+ let e!: {};
var r1a1 = a * t;
var r1a2 = a / t;
diff --git a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols
index 4228f2ffad0a5..3063f4d1a54a6 100644
--- a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols
+++ b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols
@@ -8,19 +8,19 @@ function foo(t: T) {
>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16))
>T : Symbol(T, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 13))
- var a: any;
+ let a!: any;
>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7))
- var b: boolean;
+ let b!: boolean;
>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7))
- var c: number;
+ let c!: number;
>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7))
- var d: string;
+ let d!: string;
>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7))
- var e: {};
+ let e!: {};
>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7))
var r1a1 = a * t;
diff --git a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types
index 11e91bc03c362..fd7f11770780c 100644
--- a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types
+++ b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types
@@ -8,23 +8,23 @@ function foo(t: T) {
>t : T
> : ^
- var a: any;
+ let a!: any;
>a : any
> : ^^^
- var b: boolean;
+ let b!: boolean;
>b : boolean
> : ^^^^^^^
- var c: number;
+ let c!: number;
>c : number
> : ^^^^^^
- var d: string;
+ let d!: string;
>d : string
> : ^^^^^^
- var e: {};
+ let e!: {};
>e : {}
> : ^^
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt
index 2597dbc861257..35ab0d3f2ec19 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt
@@ -244,9 +244,9 @@ arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(176,18): error TS18050
// If one operand is the undefined or undefined value, it is treated as having the type of the
// other operand.
- var a: boolean;
- var b: string;
- var c: Object;
+ declare var a: boolean;
+ declare var b: string;
+ declare var c: Object;
// operator *
var r1a1 = undefined * a;
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.js b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.js
index e50c37344ca49..a771640b820d3 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.js
@@ -4,9 +4,9 @@
// If one operand is the undefined or undefined value, it is treated as having the type of the
// other operand.
-var a: boolean;
-var b: string;
-var c: Object;
+declare var a: boolean;
+declare var b: string;
+declare var c: Object;
// operator *
var r1a1 = undefined * a;
@@ -181,9 +181,6 @@ var r10d3 = {} | undefined;
//// [arithmeticOperatorWithUndefinedValueAndInvalidOperands.js]
// If one operand is the undefined or undefined value, it is treated as having the type of the
// other operand.
-var a;
-var b;
-var c;
// operator *
var r1a1 = undefined * a;
var r1a2 = undefined * b;
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols
index a0c409aaf92b4..6c6643316a38c 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols
@@ -4,45 +4,45 @@
// If one operand is the undefined or undefined value, it is treated as having the type of the
// other operand.
-var a: boolean;
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+declare var a: boolean;
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
-var b: string;
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+declare var b: string;
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
-var c: Object;
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+declare var c: Object;
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
// operator *
var r1a1 = undefined * a;
>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 8, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r1a2 = undefined * b;
>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 9, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r1a3 = undefined * c;
>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 10, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r1b1 = a * undefined;
>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 12, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r1b2 = b * undefined;
>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 13, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r1b3 = c * undefined;
>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 14, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r1c1 = undefined * true;
@@ -73,31 +73,31 @@ var r1d3 = {} * undefined;
var r2a1 = undefined / a;
>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 25, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r2a2 = undefined / b;
>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 26, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r2a3 = undefined / c;
>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 27, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r2b1 = a / undefined;
>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 29, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r2b2 = b / undefined;
>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 30, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r2b3 = c / undefined;
>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 31, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r2c1 = undefined / true;
@@ -128,31 +128,31 @@ var r2d3 = {} / undefined;
var r3a1 = undefined % a;
>r3a1 : Symbol(r3a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 42, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r3a2 = undefined % b;
>r3a2 : Symbol(r3a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 43, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r3a3 = undefined % c;
>r3a3 : Symbol(r3a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 44, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r3b1 = a % undefined;
>r3b1 : Symbol(r3b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 46, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r3b2 = b % undefined;
>r3b2 : Symbol(r3b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 47, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r3b3 = c % undefined;
>r3b3 : Symbol(r3b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 48, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r3c1 = undefined % true;
@@ -183,31 +183,31 @@ var r3d3 = {} % undefined;
var r4a1 = undefined - a;
>r4a1 : Symbol(r4a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 59, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r4a2 = undefined - b;
>r4a2 : Symbol(r4a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 60, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r4a3 = undefined - c;
>r4a3 : Symbol(r4a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 61, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r4b1 = a - undefined;
>r4b1 : Symbol(r4b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 63, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r4b2 = b - undefined;
>r4b2 : Symbol(r4b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 64, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r4b3 = c - undefined;
>r4b3 : Symbol(r4b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 65, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r4c1 = undefined - true;
@@ -238,31 +238,31 @@ var r4d3 = {} - undefined;
var r5a1 = undefined << a;
>r5a1 : Symbol(r5a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 76, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r5a2 = undefined << b;
>r5a2 : Symbol(r5a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 77, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r5a3 = undefined << c;
>r5a3 : Symbol(r5a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 78, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r5b1 = a << undefined;
>r5b1 : Symbol(r5b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 80, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r5b2 = b << undefined;
>r5b2 : Symbol(r5b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 81, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r5b3 = c << undefined;
>r5b3 : Symbol(r5b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 82, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r5c1 = undefined << true;
@@ -293,31 +293,31 @@ var r5d3 = {} << undefined;
var r6a1 = undefined >> a;
>r6a1 : Symbol(r6a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 93, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r6a2 = undefined >> b;
>r6a2 : Symbol(r6a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 94, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r6a3 = undefined >> c;
>r6a3 : Symbol(r6a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 95, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r6b1 = a >> undefined;
>r6b1 : Symbol(r6b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 97, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r6b2 = b >> undefined;
>r6b2 : Symbol(r6b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 98, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r6b3 = c >> undefined;
>r6b3 : Symbol(r6b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 99, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r6c1 = undefined >> true;
@@ -348,31 +348,31 @@ var r6d3 = {} >> undefined;
var r7a1 = undefined >>> a;
>r7a1 : Symbol(r7a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 110, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r7a2 = undefined >>> b;
>r7a2 : Symbol(r7a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 111, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r7a3 = undefined >>> c;
>r7a3 : Symbol(r7a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 112, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r7b1 = a >>> undefined;
>r7b1 : Symbol(r7b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 114, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r7b2 = b >>> undefined;
>r7b2 : Symbol(r7b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 115, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r7b3 = c >>> undefined;
>r7b3 : Symbol(r7b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 116, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r7c1 = undefined >>> true;
@@ -403,31 +403,31 @@ var r7d3 = {} >>> undefined;
var r8a1 = undefined & a;
>r8a1 : Symbol(r8a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 127, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r8a2 = undefined & b;
>r8a2 : Symbol(r8a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 128, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r8a3 = undefined & c;
>r8a3 : Symbol(r8a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 129, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r8b1 = a & undefined;
>r8b1 : Symbol(r8b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 131, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r8b2 = b & undefined;
>r8b2 : Symbol(r8b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 132, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r8b3 = c & undefined;
>r8b3 : Symbol(r8b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 133, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r8c1 = undefined & true;
@@ -458,31 +458,31 @@ var r8d3 = {} & undefined;
var r9a1 = undefined ^ a;
>r9a1 : Symbol(r9a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 144, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r9a2 = undefined ^ b;
>r9a2 : Symbol(r9a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 145, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r9a3 = undefined ^ c;
>r9a3 : Symbol(r9a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 146, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r9b1 = a ^ undefined;
>r9b1 : Symbol(r9b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 148, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r9b2 = b ^ undefined;
>r9b2 : Symbol(r9b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 149, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r9b3 = c ^ undefined;
>r9b3 : Symbol(r9b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 150, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r9c1 = undefined ^ true;
@@ -513,31 +513,31 @@ var r9d3 = {} ^ undefined;
var r10a1 = undefined | a;
>r10a1 : Symbol(r10a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 161, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
var r10a2 = undefined | b;
>r10a2 : Symbol(r10a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 162, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
var r10a3 = undefined | c;
>r10a3 : Symbol(r10a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 163, 3))
>undefined : Symbol(undefined)
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
var r10b1 = a | undefined;
>r10b1 : Symbol(r10b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 165, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 11))
>undefined : Symbol(undefined)
var r10b2 = b | undefined;
>r10b2 : Symbol(r10b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 166, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 11))
>undefined : Symbol(undefined)
var r10b3 = c | undefined;
>r10b3 : Symbol(r10b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 167, 3))
->c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3))
+>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 11))
>undefined : Symbol(undefined)
var r10c1 = undefined | true;
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types
index 6c3ec53c7c60a..d5334eca68273 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types
@@ -4,15 +4,15 @@
// If one operand is the undefined or undefined value, it is treated as having the type of the
// other operand.
-var a: boolean;
+declare var a: boolean;
>a : boolean
> : ^^^^^^^
-var b: string;
+declare var b: string;
>b : string
> : ^^^^^^
-var c: Object;
+declare var c: Object;
>c : Object
> : ^^^^^^
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt
index 53924924d504e..79c343eb2edca 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt
@@ -89,8 +89,8 @@ arithmeticOperatorWithUndefinedValueAndValidOperands.ts(110,17): error TS18050:
b
}
- var a: any;
- var b: number;
+ declare var a: any;
+ declare var b: number;
// operator *
var ra1 = undefined * a;
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js
index fdb16d22f3009..b87edf044ecd8 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js
@@ -9,8 +9,8 @@ enum E {
b
}
-var a: any;
-var b: number;
+declare var a: any;
+declare var b: number;
// operator *
var ra1 = undefined * a;
@@ -120,8 +120,6 @@ var E;
E[E["a"] = 0] = "a";
E[E["b"] = 1] = "b";
})(E || (E = {}));
-var a;
-var b;
// operator *
var ra1 = undefined * a;
var ra2 = undefined * b;
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.symbols
index 6219bebd69096..e3f247befa219 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.symbols
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.symbols
@@ -14,22 +14,22 @@ enum E {
>b : Symbol(E.b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 4, 6))
}
-var a: any;
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+declare var a: any;
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
-var b: number;
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+declare var b: number;
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
// operator *
var ra1 = undefined * a;
>ra1 : Symbol(ra1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 12, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var ra2 = undefined * b;
>ra2 : Symbol(ra2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 13, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var ra3 = undefined * 1;
>ra3 : Symbol(ra3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 14, 3))
@@ -44,12 +44,12 @@ var ra4 = undefined * E.a;
var ra5 = a * undefined;
>ra5 : Symbol(ra5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 16, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var ra6 = b * undefined;
>ra6 : Symbol(ra6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 17, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var ra7 = 0 * undefined;
@@ -67,12 +67,12 @@ var ra8 = E.b * undefined;
var rb1 = undefined / a;
>rb1 : Symbol(rb1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 22, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rb2 = undefined / b;
>rb2 : Symbol(rb2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 23, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rb3 = undefined / 1;
>rb3 : Symbol(rb3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 24, 3))
@@ -87,12 +87,12 @@ var rb4 = undefined / E.a;
var rb5 = a / undefined;
>rb5 : Symbol(rb5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 26, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rb6 = b / undefined;
>rb6 : Symbol(rb6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 27, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rb7 = 0 / undefined;
@@ -110,12 +110,12 @@ var rb8 = E.b / undefined;
var rc1 = undefined % a;
>rc1 : Symbol(rc1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 32, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rc2 = undefined % b;
>rc2 : Symbol(rc2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 33, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rc3 = undefined % 1;
>rc3 : Symbol(rc3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 34, 3))
@@ -130,12 +130,12 @@ var rc4 = undefined % E.a;
var rc5 = a % undefined;
>rc5 : Symbol(rc5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 36, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rc6 = b % undefined;
>rc6 : Symbol(rc6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 37, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rc7 = 0 % undefined;
@@ -153,12 +153,12 @@ var rc8 = E.b % undefined;
var rd1 = undefined - a;
>rd1 : Symbol(rd1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 42, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rd2 = undefined - b;
>rd2 : Symbol(rd2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 43, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rd3 = undefined - 1;
>rd3 : Symbol(rd3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 44, 3))
@@ -173,12 +173,12 @@ var rd4 = undefined - E.a;
var rd5 = a - undefined;
>rd5 : Symbol(rd5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 46, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rd6 = b - undefined;
>rd6 : Symbol(rd6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 47, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rd7 = 0 - undefined;
@@ -196,12 +196,12 @@ var rd8 = E.b - undefined;
var re1 = undefined << a;
>re1 : Symbol(re1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 52, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var re2 = undefined << b;
>re2 : Symbol(re2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 53, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var re3 = undefined << 1;
>re3 : Symbol(re3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 54, 3))
@@ -216,12 +216,12 @@ var re4 = undefined << E.a;
var re5 = a << undefined;
>re5 : Symbol(re5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 56, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var re6 = b << undefined;
>re6 : Symbol(re6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 57, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var re7 = 0 << undefined;
@@ -239,12 +239,12 @@ var re8 = E.b << undefined;
var rf1 = undefined >> a;
>rf1 : Symbol(rf1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 62, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rf2 = undefined >> b;
>rf2 : Symbol(rf2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 63, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rf3 = undefined >> 1;
>rf3 : Symbol(rf3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 64, 3))
@@ -259,12 +259,12 @@ var rf4 = undefined >> E.a;
var rf5 = a >> undefined;
>rf5 : Symbol(rf5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 66, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rf6 = b >> undefined;
>rf6 : Symbol(rf6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 67, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rf7 = 0 >> undefined;
@@ -282,12 +282,12 @@ var rf8 = E.b >> undefined;
var rg1 = undefined >>> a;
>rg1 : Symbol(rg1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 72, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rg2 = undefined >>> b;
>rg2 : Symbol(rg2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 73, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rg3 = undefined >>> 1;
>rg3 : Symbol(rg3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 74, 3))
@@ -302,12 +302,12 @@ var rg4 = undefined >>> E.a;
var rg5 = a >>> undefined;
>rg5 : Symbol(rg5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 76, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rg6 = b >>> undefined;
>rg6 : Symbol(rg6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 77, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rg7 = 0 >>> undefined;
@@ -325,12 +325,12 @@ var rg8 = E.b >>> undefined;
var rh1 = undefined & a;
>rh1 : Symbol(rh1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 82, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rh2 = undefined & b;
>rh2 : Symbol(rh2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 83, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rh3 = undefined & 1;
>rh3 : Symbol(rh3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 84, 3))
@@ -345,12 +345,12 @@ var rh4 = undefined & E.a;
var rh5 = a & undefined;
>rh5 : Symbol(rh5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 86, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rh6 = b & undefined;
>rh6 : Symbol(rh6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 87, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rh7 = 0 & undefined;
@@ -368,12 +368,12 @@ var rh8 = E.b & undefined;
var ri1 = undefined ^ a;
>ri1 : Symbol(ri1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 92, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var ri2 = undefined ^ b;
>ri2 : Symbol(ri2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 93, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var ri3 = undefined ^ 1;
>ri3 : Symbol(ri3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 94, 3))
@@ -388,12 +388,12 @@ var ri4 = undefined ^ E.a;
var ri5 = a ^ undefined;
>ri5 : Symbol(ri5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 96, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var ri6 = b ^ undefined;
>ri6 : Symbol(ri6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 97, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var ri7 = 0 ^ undefined;
@@ -411,12 +411,12 @@ var ri8 = E.b ^ undefined;
var rj1 = undefined | a;
>rj1 : Symbol(rj1, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 102, 3))
>undefined : Symbol(undefined)
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
var rj2 = undefined | b;
>rj2 : Symbol(rj2, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 103, 3))
>undefined : Symbol(undefined)
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
var rj3 = undefined | 1;
>rj3 : Symbol(rj3, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 104, 3))
@@ -431,12 +431,12 @@ var rj4 = undefined | E.a;
var rj5 = a | undefined;
>rj5 : Symbol(rj5, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 106, 3))
->a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 8, 11))
>undefined : Symbol(undefined)
var rj6 = b | undefined;
>rj6 : Symbol(rj6, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 107, 3))
->b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndValidOperands.ts, 9, 11))
>undefined : Symbol(undefined)
var rj7 = 0 | undefined;
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.types b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.types
index 607c764e48c2e..37f3d457e99ca 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.types
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.types
@@ -17,11 +17,11 @@ enum E {
> : ^^^
}
-var a: any;
+declare var a: any;
>a : any
> : ^^^
-var b: number;
+declare var b: number;
>b : number
> : ^^^^^^
diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
index b4e4cdbcf67a4..188e9e1160afc 100644
--- a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
+++ b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
@@ -36,9 +36,9 @@ arityAndOrderCompatibility01.ts(32,5): error TS2322: Type '{ 0: string; 1: numbe
length: 2;
}
- var x: [string, number];
- var y: StrNum
- var z: {
+ declare var x: [string, number];
+ declare var y: StrNum
+ declare var z: {
0: string;
1: number;
length: 2;
diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.js b/tests/baselines/reference/arityAndOrderCompatibility01.js
index 81f2df8dd8165..4226f80656b02 100644
--- a/tests/baselines/reference/arityAndOrderCompatibility01.js
+++ b/tests/baselines/reference/arityAndOrderCompatibility01.js
@@ -7,9 +7,9 @@ interface StrNum extends Array {
length: 2;
}
-var x: [string, number];
-var y: StrNum
-var z: {
+declare var x: [string, number];
+declare var y: StrNum
+declare var z: {
0: string;
1: number;
length: 2;
@@ -39,9 +39,6 @@ var o3: [string, number] = y;
//// [arityAndOrderCompatibility01.js]
-var x;
-var y;
-var z;
var a = x[0], b = x[1], c = x[2];
var d = y[0], e = y[1], f = y[2];
var g = z[0], h = z[1], i = z[2];
diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.symbols b/tests/baselines/reference/arityAndOrderCompatibility01.symbols
index b3cde5bd55213..aa22946313bad 100644
--- a/tests/baselines/reference/arityAndOrderCompatibility01.symbols
+++ b/tests/baselines/reference/arityAndOrderCompatibility01.symbols
@@ -15,18 +15,18 @@ interface StrNum extends Array {
>length : Symbol(StrNum.length, Decl(arityAndOrderCompatibility01.ts, 2, 14))
}
-var x: [string, number];
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+declare var x: [string, number];
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
-var y: StrNum
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+declare var y: StrNum
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
>StrNum : Symbol(StrNum, Decl(arityAndOrderCompatibility01.ts, 0, 0))
-var z: {
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+declare var z: {
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
0: string;
->0 : Symbol(0, Decl(arityAndOrderCompatibility01.ts, 8, 8))
+>0 : Symbol(0, Decl(arityAndOrderCompatibility01.ts, 8, 16))
1: number;
>1 : Symbol(1, Decl(arityAndOrderCompatibility01.ts, 9, 14))
@@ -39,89 +39,89 @@ var [a, b, c] = x;
>a : Symbol(a, Decl(arityAndOrderCompatibility01.ts, 14, 5))
>b : Symbol(b, Decl(arityAndOrderCompatibility01.ts, 14, 7))
>c : Symbol(c, Decl(arityAndOrderCompatibility01.ts, 14, 10))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var [d, e, f] = y;
>d : Symbol(d, Decl(arityAndOrderCompatibility01.ts, 15, 5))
>e : Symbol(e, Decl(arityAndOrderCompatibility01.ts, 15, 7))
>f : Symbol(f, Decl(arityAndOrderCompatibility01.ts, 15, 10))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var [g, h, i] = z;
>g : Symbol(g, Decl(arityAndOrderCompatibility01.ts, 16, 5))
>h : Symbol(h, Decl(arityAndOrderCompatibility01.ts, 16, 7))
>i : Symbol(i, Decl(arityAndOrderCompatibility01.ts, 16, 10))
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
var j1: [number, number, number] = x;
>j1 : Symbol(j1, Decl(arityAndOrderCompatibility01.ts, 17, 3))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var j2: [number, number, number] = y;
>j2 : Symbol(j2, Decl(arityAndOrderCompatibility01.ts, 18, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var j3: [number, number, number] = z;
>j3 : Symbol(j3, Decl(arityAndOrderCompatibility01.ts, 19, 3))
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
var k1: [string, number, number] = x;
>k1 : Symbol(k1, Decl(arityAndOrderCompatibility01.ts, 20, 3))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var k2: [string, number, number] = y;
>k2 : Symbol(k2, Decl(arityAndOrderCompatibility01.ts, 21, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var k3: [string, number, number] = z;
>k3 : Symbol(k3, Decl(arityAndOrderCompatibility01.ts, 22, 3))
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
var l1: [number] = x;
>l1 : Symbol(l1, Decl(arityAndOrderCompatibility01.ts, 23, 3))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var l2: [number] = y;
>l2 : Symbol(l2, Decl(arityAndOrderCompatibility01.ts, 24, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var l3: [number] = z;
>l3 : Symbol(l3, Decl(arityAndOrderCompatibility01.ts, 25, 3))
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
var m1: [string] = x;
>m1 : Symbol(m1, Decl(arityAndOrderCompatibility01.ts, 26, 3))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var m2: [string] = y;
>m2 : Symbol(m2, Decl(arityAndOrderCompatibility01.ts, 27, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var m3: [string] = z;
>m3 : Symbol(m3, Decl(arityAndOrderCompatibility01.ts, 28, 3))
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
var n1: [number, string] = x;
>n1 : Symbol(n1, Decl(arityAndOrderCompatibility01.ts, 29, 3))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var n2: [number, string] = y;
>n2 : Symbol(n2, Decl(arityAndOrderCompatibility01.ts, 30, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var n3: [number, string] = z;
>n3 : Symbol(n3, Decl(arityAndOrderCompatibility01.ts, 31, 3))
->z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 3))
+>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 8, 11))
var o1: [string, number] = x;
>o1 : Symbol(o1, Decl(arityAndOrderCompatibility01.ts, 32, 3))
->x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 3))
+>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 6, 11))
var o2: [string, number] = y;
>o2 : Symbol(o2, Decl(arityAndOrderCompatibility01.ts, 33, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
var o3: [string, number] = y;
>o3 : Symbol(o3, Decl(arityAndOrderCompatibility01.ts, 34, 3))
->y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 3))
+>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 7, 11))
diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.types b/tests/baselines/reference/arityAndOrderCompatibility01.types
index 5c37248c3ebc0..a7109edfe8ae1 100644
--- a/tests/baselines/reference/arityAndOrderCompatibility01.types
+++ b/tests/baselines/reference/arityAndOrderCompatibility01.types
@@ -15,15 +15,15 @@ interface StrNum extends Array {
> : ^
}
-var x: [string, number];
+declare var x: [string, number];
>x : [string, number]
> : ^^^^^^^^^^^^^^^^
-var y: StrNum
+declare var y: StrNum
>y : StrNum
> : ^^^^^^
-var z: {
+declare var z: {
>z : { 0: string; 1: number; length: 2; }
> : ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^
diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.errors.txt b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.errors.txt
index 61c9f33cada3f..a62cb8e3b56c8 100644
--- a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.errors.txt
+++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.errors.txt
@@ -1,13 +1,13 @@
-arrayLiteralAndArrayConstructorEquivalence1.ts(3,14): error TS2314: Generic type 'Array' requires 1 type argument(s).
+arrayLiteralAndArrayConstructorEquivalence1.ts(3,22): error TS2314: Generic type 'Array' requires 1 type argument(s).
==== arrayLiteralAndArrayConstructorEquivalence1.ts (1 errors) ====
var myCars=new Array();
var myCars3 = new Array({});
- var myCars4: Array; // error
- ~~~~~
+ declare var myCars4: Array; // error
+ ~~~~~
!!! error TS2314: Generic type 'Array' requires 1 type argument(s).
- var myCars5: Array[];
+ declare var myCars5: Array[];
myCars = myCars3;
myCars = myCars4;
diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.js b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.js
index 3876a90b17c2c..555eddfeeed70 100644
--- a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.js
+++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.js
@@ -3,8 +3,8 @@
//// [arrayLiteralAndArrayConstructorEquivalence1.ts]
var myCars=new Array();
var myCars3 = new Array({});
-var myCars4: Array; // error
-var myCars5: Array[];
+declare var myCars4: Array; // error
+declare var myCars5: Array[];
myCars = myCars3;
myCars = myCars4;
@@ -18,8 +18,6 @@ myCars3 = myCars5;
//// [arrayLiteralAndArrayConstructorEquivalence1.js]
var myCars = new Array();
var myCars3 = new Array({});
-var myCars4; // error
-var myCars5;
myCars = myCars3;
myCars = myCars4;
myCars = myCars5;
diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols
index 3793641e69586..c862cdf1756e6 100644
--- a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols
+++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols
@@ -9,12 +9,12 @@ var myCars3 = new Array({});
>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3))
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
-var myCars4: Array; // error
->myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 3))
+declare var myCars4: Array; // error
+>myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 11))
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
-var myCars5: Array[];
->myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 3))
+declare var myCars5: Array[];
+>myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 11))
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
myCars = myCars3;
@@ -23,11 +23,11 @@ myCars = myCars3;
myCars = myCars4;
>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3))
->myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 3))
+>myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 11))
myCars = myCars5;
>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3))
->myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 3))
+>myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 11))
myCars3 = myCars;
>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3))
@@ -35,9 +35,9 @@ myCars3 = myCars;
myCars3 = myCars4;
>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3))
->myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 3))
+>myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 11))
myCars3 = myCars5;
>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3))
->myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 3))
+>myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 11))
diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types
index 002a8c7b9ae14..5fa1a325ca9e0 100644
--- a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types
+++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types
@@ -19,11 +19,11 @@ var myCars3 = new Array({});
>{} : {}
> : ^^
-var myCars4: Array; // error
+declare var myCars4: Array; // error
>myCars4 : any
> : ^^^
-var myCars5: Array[];
+declare var myCars5: Array[];
>myCars5 : any[][]
> : ^^^^^^^
diff --git a/tests/baselines/reference/arraySigChecking.errors.txt b/tests/baselines/reference/arraySigChecking.errors.txt
index d39a86ec11622..74dbd3487bfe2 100644
--- a/tests/baselines/reference/arraySigChecking.errors.txt
+++ b/tests/baselines/reference/arraySigChecking.errors.txt
@@ -23,7 +23,7 @@ arraySigChecking.ts(22,16): error TS2322: Type 'number' is not assignable to typ
interface myInt {
voidFn(): void;
}
- var myVar: myInt;
+ declare var myVar: myInt;
var strArray: string[] = [myVar.voidFn()];
~~~~~~~~~~~~~~
!!! error TS2322: Type 'void' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/arraySigChecking.js b/tests/baselines/reference/arraySigChecking.js
index 12b13af0ef452..b114161260bad 100644
--- a/tests/baselines/reference/arraySigChecking.js
+++ b/tests/baselines/reference/arraySigChecking.js
@@ -17,7 +17,7 @@ declare namespace M {
interface myInt {
voidFn(): void;
}
-var myVar: myInt;
+declare var myVar: myInt;
var strArray: string[] = [myVar.voidFn()];
@@ -35,7 +35,6 @@ isEmpty(['a']);
//// [arraySigChecking.js]
-var myVar;
var strArray = [myVar.voidFn()];
var myArray;
myArray = [[1, 2]];
diff --git a/tests/baselines/reference/arraySigChecking.symbols b/tests/baselines/reference/arraySigChecking.symbols
index 675232020ffa8..ec798833f2f34 100644
--- a/tests/baselines/reference/arraySigChecking.symbols
+++ b/tests/baselines/reference/arraySigChecking.symbols
@@ -34,14 +34,14 @@ interface myInt {
voidFn(): void;
>voidFn : Symbol(myInt.voidFn, Decl(arraySigChecking.ts, 13, 17))
}
-var myVar: myInt;
->myVar : Symbol(myVar, Decl(arraySigChecking.ts, 16, 3))
+declare var myVar: myInt;
+>myVar : Symbol(myVar, Decl(arraySigChecking.ts, 16, 11))
>myInt : Symbol(myInt, Decl(arraySigChecking.ts, 11, 1))
var strArray: string[] = [myVar.voidFn()];
>strArray : Symbol(strArray, Decl(arraySigChecking.ts, 17, 3))
>myVar.voidFn : Symbol(myInt.voidFn, Decl(arraySigChecking.ts, 13, 17))
->myVar : Symbol(myVar, Decl(arraySigChecking.ts, 16, 3))
+>myVar : Symbol(myVar, Decl(arraySigChecking.ts, 16, 11))
>voidFn : Symbol(myInt.voidFn, Decl(arraySigChecking.ts, 13, 17))
diff --git a/tests/baselines/reference/arraySigChecking.types b/tests/baselines/reference/arraySigChecking.types
index e06a70c576933..81f479fe85ec1 100644
--- a/tests/baselines/reference/arraySigChecking.types
+++ b/tests/baselines/reference/arraySigChecking.types
@@ -36,7 +36,7 @@ interface myInt {
>voidFn : () => void
> : ^^^^^^
}
-var myVar: myInt;
+declare var myVar: myInt;
>myVar : myInt
> : ^^^^^
diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface05.errors.txt b/tests/baselines/reference/asiPreventsParsingAsInterface05.errors.txt
index 61d669aec1ff6..e8fc62fbde16d 100644
--- a/tests/baselines/reference/asiPreventsParsingAsInterface05.errors.txt
+++ b/tests/baselines/reference/asiPreventsParsingAsInterface05.errors.txt
@@ -6,7 +6,7 @@ asiPreventsParsingAsInterface05.ts(11,1): error TS2304: Cannot find name 'I'.
==== asiPreventsParsingAsInterface05.ts (3 errors) ====
"use strict"
- var interface: number;
+ var interface: number = 123;
~~~~~~~~~
!!! error TS1212: Identifier expected. 'interface' is a reserved word in strict mode.
diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface05.js b/tests/baselines/reference/asiPreventsParsingAsInterface05.js
index 82aea79bba0b6..51f002b5a9d04 100644
--- a/tests/baselines/reference/asiPreventsParsingAsInterface05.js
+++ b/tests/baselines/reference/asiPreventsParsingAsInterface05.js
@@ -3,7 +3,7 @@
//// [asiPreventsParsingAsInterface05.ts]
"use strict"
-var interface: number;
+var interface: number = 123;
// 'interface' is a strict mode reserved word, and so it would be permissible
// to allow 'interface' and the name of the interface to be on separate lines;
@@ -16,7 +16,7 @@ I // This should be the identifier 'I'
//// [asiPreventsParsingAsInterface05.js]
"use strict";
-var interface;
+var interface = 123;
// 'interface' is a strict mode reserved word, and so it would be permissible
// to allow 'interface' and the name of the interface to be on separate lines;
// however, this complicates things, and so it is preferable to restrict interface
diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols
index e3730eef1fae9..28eee75d44b0f 100644
--- a/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols
+++ b/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols
@@ -3,7 +3,7 @@
=== asiPreventsParsingAsInterface05.ts ===
"use strict"
-var interface: number;
+var interface: number = 123;
>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface05.ts, 2, 3))
// 'interface' is a strict mode reserved word, and so it would be permissible
diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface05.types b/tests/baselines/reference/asiPreventsParsingAsInterface05.types
index 504e351db0a1f..8e43fa7b75698 100644
--- a/tests/baselines/reference/asiPreventsParsingAsInterface05.types
+++ b/tests/baselines/reference/asiPreventsParsingAsInterface05.types
@@ -5,9 +5,11 @@
>"use strict" : "use strict"
> : ^^^^^^^^^^^^
-var interface: number;
+var interface: number = 123;
>interface : number
> : ^^^^^^
+>123 : 123
+> : ^^^
// 'interface' is a strict mode reserved word, and so it would be permissible
// to allow 'interface' and the name of the interface to be on separate lines;
diff --git a/tests/baselines/reference/assignFromBooleanInterface.errors.txt b/tests/baselines/reference/assignFromBooleanInterface.errors.txt
index 6671373734381..95a9628c1336b 100644
--- a/tests/baselines/reference/assignFromBooleanInterface.errors.txt
+++ b/tests/baselines/reference/assignFromBooleanInterface.errors.txt
@@ -4,7 +4,7 @@ assignFromBooleanInterface.ts(3,1): error TS2322: Type 'Boolean' is not assignab
==== assignFromBooleanInterface.ts (1 errors) ====
var x = true;
- var a: Boolean;
+ declare var a: Boolean;
x = a;
~
!!! error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
diff --git a/tests/baselines/reference/assignFromBooleanInterface.js b/tests/baselines/reference/assignFromBooleanInterface.js
index f539081384d0e..21b05dedd0d14 100644
--- a/tests/baselines/reference/assignFromBooleanInterface.js
+++ b/tests/baselines/reference/assignFromBooleanInterface.js
@@ -2,12 +2,11 @@
//// [assignFromBooleanInterface.ts]
var x = true;
-var a: Boolean;
+declare var a: Boolean;
x = a;
a = x;
//// [assignFromBooleanInterface.js]
var x = true;
-var a;
x = a;
a = x;
diff --git a/tests/baselines/reference/assignFromBooleanInterface.symbols b/tests/baselines/reference/assignFromBooleanInterface.symbols
index 4177c7169e5b0..569459faeaecc 100644
--- a/tests/baselines/reference/assignFromBooleanInterface.symbols
+++ b/tests/baselines/reference/assignFromBooleanInterface.symbols
@@ -4,15 +4,15 @@
var x = true;
>x : Symbol(x, Decl(assignFromBooleanInterface.ts, 0, 3))
-var a: Boolean;
->a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 3))
+declare var a: Boolean;
+>a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 11))
>Boolean : Symbol(Boolean, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
x = a;
>x : Symbol(x, Decl(assignFromBooleanInterface.ts, 0, 3))
->a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 3))
+>a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 11))
a = x;
->a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 3))
+>a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 11))
>x : Symbol(x, Decl(assignFromBooleanInterface.ts, 0, 3))
diff --git a/tests/baselines/reference/assignFromBooleanInterface.types b/tests/baselines/reference/assignFromBooleanInterface.types
index 8959ee10ba076..15b4bfbb9c866 100644
--- a/tests/baselines/reference/assignFromBooleanInterface.types
+++ b/tests/baselines/reference/assignFromBooleanInterface.types
@@ -7,7 +7,7 @@ var x = true;
>true : true
> : ^^^^
-var a: Boolean;
+declare var a: Boolean;
>a : Boolean
> : ^^^^^^^
diff --git a/tests/baselines/reference/assignFromBooleanInterface2.errors.txt b/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
index ebd3e9a5477b9..cb2ee61e45fbc 100644
--- a/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
@@ -16,8 +16,8 @@ assignFromBooleanInterface2.ts(20,1): error TS2322: Type 'NotBoolean' is not ass
}
var x = true;
- var a: Boolean;
- var b: NotBoolean;
+ declare var a: Boolean;
+ declare var b: NotBoolean;
a = x;
a = b;
diff --git a/tests/baselines/reference/assignFromBooleanInterface2.js b/tests/baselines/reference/assignFromBooleanInterface2.js
index 5a903182bb980..0ac4657706ff4 100644
--- a/tests/baselines/reference/assignFromBooleanInterface2.js
+++ b/tests/baselines/reference/assignFromBooleanInterface2.js
@@ -10,8 +10,8 @@ interface NotBoolean {
}
var x = true;
-var a: Boolean;
-var b: NotBoolean;
+declare var a: Boolean;
+declare var b: NotBoolean;
a = x;
a = b;
@@ -26,8 +26,6 @@ x = b; // expected error
//// [assignFromBooleanInterface2.js]
var x = true;
-var a;
-var b;
a = x;
a = b;
b = a;
diff --git a/tests/baselines/reference/assignFromBooleanInterface2.symbols b/tests/baselines/reference/assignFromBooleanInterface2.symbols
index 1d3dc6b474e0c..51cfc18382fea 100644
--- a/tests/baselines/reference/assignFromBooleanInterface2.symbols
+++ b/tests/baselines/reference/assignFromBooleanInterface2.symbols
@@ -18,36 +18,36 @@ interface NotBoolean {
var x = true;
>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3))
-var a: Boolean;
->a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3))
+declare var a: Boolean;
+>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 11))
>Boolean : Symbol(Boolean, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(assignFromBooleanInterface2.ts, 0, 0))
-var b: NotBoolean;
->b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3))
+declare var b: NotBoolean;
+>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 11))
>NotBoolean : Symbol(NotBoolean, Decl(assignFromBooleanInterface2.ts, 2, 1))
a = x;
->a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3))
+>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 11))
>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3))
a = b;
->a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3))
->b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3))
+>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 11))
+>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 11))
b = a;
->b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3))
->a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3))
+>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 11))
+>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 11))
b = x;
->b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3))
+>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 11))
>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3))
x = a; // expected error
>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3))
->a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3))
+>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 11))
x = b; // expected error
>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3))
->b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3))
+>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 11))
diff --git a/tests/baselines/reference/assignFromBooleanInterface2.types b/tests/baselines/reference/assignFromBooleanInterface2.types
index 75691bba1997b..0038c4b696d03 100644
--- a/tests/baselines/reference/assignFromBooleanInterface2.types
+++ b/tests/baselines/reference/assignFromBooleanInterface2.types
@@ -19,11 +19,11 @@ var x = true;
>true : true
> : ^^^^
-var a: Boolean;
+declare var a: Boolean;
>a : Boolean
> : ^^^^^^^
-var b: NotBoolean;
+declare var b: NotBoolean;
>b : NotBoolean
> : ^^^^^^^^^^
diff --git a/tests/baselines/reference/assignFromNumberInterface.errors.txt b/tests/baselines/reference/assignFromNumberInterface.errors.txt
index 421e4d34e5c2e..bc3e7f8f40ca2 100644
--- a/tests/baselines/reference/assignFromNumberInterface.errors.txt
+++ b/tests/baselines/reference/assignFromNumberInterface.errors.txt
@@ -4,7 +4,7 @@ assignFromNumberInterface.ts(3,1): error TS2322: Type 'Number' is not assignable
==== assignFromNumberInterface.ts (1 errors) ====
var x = 1;
- var a: Number;
+ declare var a: Number;
x = a;
~
!!! error TS2322: Type 'Number' is not assignable to type 'number'.
diff --git a/tests/baselines/reference/assignFromNumberInterface.js b/tests/baselines/reference/assignFromNumberInterface.js
index ea4cd1b8b6814..d4b57147fd22c 100644
--- a/tests/baselines/reference/assignFromNumberInterface.js
+++ b/tests/baselines/reference/assignFromNumberInterface.js
@@ -2,12 +2,11 @@
//// [assignFromNumberInterface.ts]
var x = 1;
-var a: Number;
+declare var a: Number;
x = a;
a = x;
//// [assignFromNumberInterface.js]
var x = 1;
-var a;
x = a;
a = x;
diff --git a/tests/baselines/reference/assignFromNumberInterface.symbols b/tests/baselines/reference/assignFromNumberInterface.symbols
index f0f7c8443d81c..35300e180e8e3 100644
--- a/tests/baselines/reference/assignFromNumberInterface.symbols
+++ b/tests/baselines/reference/assignFromNumberInterface.symbols
@@ -4,15 +4,15 @@
var x = 1;
>x : Symbol(x, Decl(assignFromNumberInterface.ts, 0, 3))
-var a: Number;
->a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 3))
+declare var a: Number;
+>a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 11))
>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
x = a;
>x : Symbol(x, Decl(assignFromNumberInterface.ts, 0, 3))
->a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 3))
+>a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 11))
a = x;
->a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 3))
+>a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 11))
>x : Symbol(x, Decl(assignFromNumberInterface.ts, 0, 3))
diff --git a/tests/baselines/reference/assignFromNumberInterface.types b/tests/baselines/reference/assignFromNumberInterface.types
index ad33c6cccaa47..92edae097dd3e 100644
--- a/tests/baselines/reference/assignFromNumberInterface.types
+++ b/tests/baselines/reference/assignFromNumberInterface.types
@@ -7,7 +7,7 @@ var x = 1;
>1 : 1
> : ^
-var a: Number;
+declare var a: Number;
>a : Number
> : ^^^^^^
diff --git a/tests/baselines/reference/assignFromNumberInterface2.errors.txt b/tests/baselines/reference/assignFromNumberInterface2.errors.txt
index eae1519fd6d6d..112f1a5fc0023 100644
--- a/tests/baselines/reference/assignFromNumberInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromNumberInterface2.errors.txt
@@ -18,8 +18,8 @@ assignFromNumberInterface2.ts(25,1): error TS2322: Type 'NotNumber' is not assig
}
var x = 1;
- var a: Number;
- var b: NotNumber;
+ declare var a: Number;
+ declare var b: NotNumber;
a = x;
a = b;
diff --git a/tests/baselines/reference/assignFromNumberInterface2.js b/tests/baselines/reference/assignFromNumberInterface2.js
index fac0aba9ff5e9..7fd396aa7673d 100644
--- a/tests/baselines/reference/assignFromNumberInterface2.js
+++ b/tests/baselines/reference/assignFromNumberInterface2.js
@@ -15,8 +15,8 @@ interface NotNumber {
}
var x = 1;
-var a: Number;
-var b: NotNumber;
+declare var a: Number;
+declare var b: NotNumber;
a = x;
a = b;
@@ -31,8 +31,6 @@ x = b; // expected error
//// [assignFromNumberInterface2.js]
var x = 1;
-var a;
-var b;
a = x;
a = b;
b = a;
diff --git a/tests/baselines/reference/assignFromNumberInterface2.symbols b/tests/baselines/reference/assignFromNumberInterface2.symbols
index 2a1f46e208195..a163ba3a31afd 100644
--- a/tests/baselines/reference/assignFromNumberInterface2.symbols
+++ b/tests/baselines/reference/assignFromNumberInterface2.symbols
@@ -37,36 +37,36 @@ interface NotNumber {
var x = 1;
>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3))
-var a: Number;
->a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3))
+declare var a: Number;
+>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 11))
>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(assignFromNumberInterface2.ts, 0, 0))
-var b: NotNumber;
->b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3))
+declare var b: NotNumber;
+>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 11))
>NotNumber : Symbol(NotNumber, Decl(assignFromNumberInterface2.ts, 2, 1))
a = x;
->a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3))
+>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 11))
>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3))
a = b;
->a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3))
->b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3))
+>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 11))
+>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 11))
b = a;
->b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3))
->a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3))
+>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 11))
+>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 11))
b = x;
->b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3))
+>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 11))
>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3))
x = a; // expected error
>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3))
->a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3))
+>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 11))
x = b; // expected error
>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3))
->b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3))
+>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 11))
diff --git a/tests/baselines/reference/assignFromNumberInterface2.types b/tests/baselines/reference/assignFromNumberInterface2.types
index fb717bf271921..c3cc6fb24a7db 100644
--- a/tests/baselines/reference/assignFromNumberInterface2.types
+++ b/tests/baselines/reference/assignFromNumberInterface2.types
@@ -47,11 +47,11 @@ var x = 1;
>1 : 1
> : ^
-var a: Number;
+declare var a: Number;
>a : Number
> : ^^^^^^
-var b: NotNumber;
+declare var b: NotNumber;
>b : NotNumber
> : ^^^^^^^^^
diff --git a/tests/baselines/reference/assignFromStringInterface.errors.txt b/tests/baselines/reference/assignFromStringInterface.errors.txt
index d01a2c1e33524..d043b7155812c 100644
--- a/tests/baselines/reference/assignFromStringInterface.errors.txt
+++ b/tests/baselines/reference/assignFromStringInterface.errors.txt
@@ -4,7 +4,7 @@ assignFromStringInterface.ts(3,1): error TS2322: Type 'String' is not assignable
==== assignFromStringInterface.ts (1 errors) ====
var x = '';
- var a: String;
+ declare var a: String;
x = a;
~
!!! error TS2322: Type 'String' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/assignFromStringInterface.js b/tests/baselines/reference/assignFromStringInterface.js
index c458439013a2f..bb220c9ae28f8 100644
--- a/tests/baselines/reference/assignFromStringInterface.js
+++ b/tests/baselines/reference/assignFromStringInterface.js
@@ -2,12 +2,11 @@
//// [assignFromStringInterface.ts]
var x = '';
-var a: String;
+declare var a: String;
x = a;
a = x;
//// [assignFromStringInterface.js]
var x = '';
-var a;
x = a;
a = x;
diff --git a/tests/baselines/reference/assignFromStringInterface.symbols b/tests/baselines/reference/assignFromStringInterface.symbols
index 3b128582ab842..6f82db0b86eb0 100644
--- a/tests/baselines/reference/assignFromStringInterface.symbols
+++ b/tests/baselines/reference/assignFromStringInterface.symbols
@@ -4,15 +4,15 @@
var x = '';
>x : Symbol(x, Decl(assignFromStringInterface.ts, 0, 3))
-var a: String;
->a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 3))
+declare var a: String;
+>a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 11))
>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
x = a;
>x : Symbol(x, Decl(assignFromStringInterface.ts, 0, 3))
->a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 3))
+>a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 11))
a = x;
->a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 3))
+>a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 11))
>x : Symbol(x, Decl(assignFromStringInterface.ts, 0, 3))
diff --git a/tests/baselines/reference/assignFromStringInterface.types b/tests/baselines/reference/assignFromStringInterface.types
index 7c921267f7ee8..7a434edc5986a 100644
--- a/tests/baselines/reference/assignFromStringInterface.types
+++ b/tests/baselines/reference/assignFromStringInterface.types
@@ -7,7 +7,7 @@ var x = '';
>'' : ""
> : ^^
-var a: String;
+declare var a: String;
>a : String
> : ^^^^^^
diff --git a/tests/baselines/reference/assignFromStringInterface2.errors.txt b/tests/baselines/reference/assignFromStringInterface2.errors.txt
index 3517bf4d1d9f4..6aff3eb4bce0f 100644
--- a/tests/baselines/reference/assignFromStringInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromStringInterface2.errors.txt
@@ -42,8 +42,8 @@ assignFromStringInterface2.ts(48,1): error TS2322: Type 'NotString' is not assig
}
var x = '';
- var a: String;
- var b: NotString;
+ declare var a: String;
+ declare var b: NotString;
a = x;
a = b;
diff --git a/tests/baselines/reference/assignFromStringInterface2.js b/tests/baselines/reference/assignFromStringInterface2.js
index 308491f89cee8..653ba0bce6ef0 100644
--- a/tests/baselines/reference/assignFromStringInterface2.js
+++ b/tests/baselines/reference/assignFromStringInterface2.js
@@ -38,8 +38,8 @@ interface NotString {
}
var x = '';
-var a: String;
-var b: NotString;
+declare var a: String;
+declare var b: NotString;
a = x;
a = b;
@@ -54,8 +54,6 @@ x = b; // expected error
//// [assignFromStringInterface2.js]
var x = '';
-var a;
-var b;
a = x;
a = b;
b = a;
diff --git a/tests/baselines/reference/assignFromStringInterface2.symbols b/tests/baselines/reference/assignFromStringInterface2.symbols
index d1e77cda723f8..f0a452d9e6d59 100644
--- a/tests/baselines/reference/assignFromStringInterface2.symbols
+++ b/tests/baselines/reference/assignFromStringInterface2.symbols
@@ -143,36 +143,36 @@ interface NotString {
var x = '';
>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3))
-var a: String;
->a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3))
+declare var a: String;
+>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 11))
>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 2 more)
-var b: NotString;
->b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3))
+declare var b: NotString;
+>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 11))
>NotString : Symbol(NotString, Decl(assignFromStringInterface2.ts, 2, 1))
a = x;
->a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3))
+>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 11))
>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3))
a = b;
->a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3))
->b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3))
+>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 11))
+>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 11))
b = a;
->b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3))
->a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3))
+>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 11))
+>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 11))
b = x;
->b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3))
+>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 11))
>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3))
x = a; // expected error
>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3))
->a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3))
+>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 11))
x = b; // expected error
>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3))
->b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3))
+>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 11))
diff --git a/tests/baselines/reference/assignFromStringInterface2.types b/tests/baselines/reference/assignFromStringInterface2.types
index ad5e66cff4334..07abd49b32fc4 100644
--- a/tests/baselines/reference/assignFromStringInterface2.types
+++ b/tests/baselines/reference/assignFromStringInterface2.types
@@ -199,11 +199,11 @@ var x = '';
>'' : ""
> : ^^
-var a: String;
+declare var a: String;
>a : String
> : ^^^^^^
-var b: NotString;
+declare var b: NotString;
>b : NotString
> : ^^^^^^^^^
diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt b/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt
index 828311e627ef9..5252d2b49a4ab 100644
--- a/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt
+++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt
@@ -7,7 +7,7 @@ assigningFromObjectToAnythingElse.ts(8,5): error TS2696: The 'Object' type is as
==== assigningFromObjectToAnythingElse.ts (4 errors) ====
- var x: Object;
+ declare var x: Object;
var y: RegExp;
y = x;
~
diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.js b/tests/baselines/reference/assigningFromObjectToAnythingElse.js
index 39cddae6eee45..393cda52bead6 100644
--- a/tests/baselines/reference/assigningFromObjectToAnythingElse.js
+++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.js
@@ -1,7 +1,7 @@
//// [tests/cases/compiler/assigningFromObjectToAnythingElse.ts] ////
//// [assigningFromObjectToAnythingElse.ts]
-var x: Object;
+declare var x: Object;
var y: RegExp;
y = x;
@@ -12,7 +12,6 @@ var w: Error = new Object();
//// [assigningFromObjectToAnythingElse.js]
-var x;
var y;
y = x;
var a = Object.create("");
diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols b/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols
index b9981cbf27c77..2dfe427e64294 100644
--- a/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols
+++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols
@@ -1,8 +1,8 @@
//// [tests/cases/compiler/assigningFromObjectToAnythingElse.ts] ////
=== assigningFromObjectToAnythingElse.ts ===
-var x: Object;
->x : Symbol(x, Decl(assigningFromObjectToAnythingElse.ts, 0, 3))
+declare var x: Object;
+>x : Symbol(x, Decl(assigningFromObjectToAnythingElse.ts, 0, 11))
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
var y: RegExp;
@@ -11,7 +11,7 @@ var y: RegExp;
y = x;
>y : Symbol(y, Decl(assigningFromObjectToAnythingElse.ts, 1, 3))
->x : Symbol(x, Decl(assigningFromObjectToAnythingElse.ts, 0, 3))
+>x : Symbol(x, Decl(assigningFromObjectToAnythingElse.ts, 0, 11))
var a: String = Object.create